muonroi-cli 1.4.0 → 1.4.1

package/src/cli/bw-vault.ts

@@ -1,184 +0,0 @@
-import { type SpawnSyncReturns, spawnSync } from "node:child_process";
-
-/**
- * Thin wrapper around the Bitwarden CLI for writing secrets into the user's
- * vault. Mirrors the assumptions of `runKeysImportBw`: the secret lives in the
- * `notes` field of a Secure Note item named `<prefix><id>`.
- *
- * Auth contract: caller must have `bw` in PATH and `BW_SESSION` exported.
- * On any error the returned object has `ok: false` so callers can degrade
- * gracefully (e.g. fall back to writing only the OS keychain).
- */
-
-export interface BwWriteResult {
-  ok: boolean;
-  action?: "created" | "updated";
-  error?: string;
-}
-
-interface BwListItem {
-  id: string;
-  name: string;
-  notes?: string | null;
-  type: number;
-}
-
-type Runner = (cmd: string, args: string[], input?: string) => SpawnSyncReturns<string>;
-
-const defaultRunner: Runner = (cmd, args, input) => spawnSync(cmd, args, { encoding: "utf8", input });
-
-function ensureUnlocked(session: string, run: Runner): { ok: true } | { ok: false; error: string } {
-  const status = run("bw", ["status", "--session", session]);
-  if (status.status !== 0) {
-    return { ok: false, error: `bw status failed: ${status.stderr || status.stdout}` };
-  }
-  let parsed: { status?: string };
-  try {
-    parsed = JSON.parse(status.stdout);
-  } catch {
-    parsed = {};
-  }
-  if (parsed.status !== "unlocked") {
-    return { ok: false, error: `Bitwarden vault is not unlocked (status: ${parsed.status ?? "unknown"})` };
-  }
-  return { ok: true };
-}
-
-function findExistingItem(name: string, session: string, run: Runner): BwListItem | null {
-  const list = run("bw", ["list", "items", "--search", name, "--session", session]);
-  if (list.status !== 0) return null;
-  let items: BwListItem[];
-  try {
-    items = JSON.parse(list.stdout) as BwListItem[];
-  } catch {
-    return null;
-  }
-  return items.find((it) => it.name === name) ?? null;
-}
-
-/**
- * Write `notes` into a vault item named `name`. Creates a Secure Note if
- * absent; updates the notes field if present. Calls `bw sync` after a write
- * so subsequent `bw get` calls see the new value.
- */
-export async function writeBwSecureNote(
-  name: string,
-  notes: string,
-  options: { runner?: Runner } = {},
-): Promise<BwWriteResult> {
-  const run = options.runner ?? defaultRunner;
-
-  const which = run("bw", ["--version"]);
-  if (which.status !== 0) {
-    return { ok: false, error: "Bitwarden CLI ('bw') not found in PATH. Install: https://bitwarden.com/help/cli/" };
-  }
-
-  const session = process.env.BW_SESSION;
-  if (!session) {
-    return { ok: false, error: "BW_SESSION not set. Run: export BW_SESSION=$(bw unlock --raw)" };
-  }
-
-  const unlock = ensureUnlocked(session, run);
-  if (!unlock.ok) return { ok: false, error: unlock.error };
-
-  const existing = findExistingItem(name, session, run);
-
-  if (existing) {
-    const updated = { ...existing, notes };
-    const encoded = run("bw", ["encode"], JSON.stringify(updated));
-    if (encoded.status !== 0) {
-      return { ok: false, error: `bw encode failed: ${encoded.stderr || encoded.stdout}` };
-    }
-    const edit = run("bw", ["edit", "item", existing.id, encoded.stdout.trim(), "--session", session]);
-    if (edit.status !== 0) {
-      return { ok: false, error: `bw edit failed: ${edit.stderr || edit.stdout}` };
-    }
-    run("bw", ["sync", "--session", session]);
-    return { ok: true, action: "updated" };
-  }
-
-  // Create a new Secure Note. Type 2 = secure note; secureNote.type 0 = generic.
-  const item = {
-    type: 2,
-    name,
-    notes,
-    secureNote: { type: 0 },
-  };
-  const encoded = run("bw", ["encode"], JSON.stringify(item));
-  if (encoded.status !== 0) {
-    return { ok: false, error: `bw encode failed: ${encoded.stderr || encoded.stdout}` };
-  }
-  const create = run("bw", ["create", "item", encoded.stdout.trim(), "--session", session]);
-  if (create.status !== 0) {
-    return { ok: false, error: `bw create failed: ${create.stderr || create.stdout}` };
-  }
-  run("bw", ["sync", "--session", session]);
-  return { ok: true, action: "created" };
-}
-
-// ─── Interactive helpers used by the TUI (no env-var, no shell ceremony) ────
-
-export interface BwUnlockResult {
-  ok: boolean;
-  session?: string;
-  error?: string;
-}
-
-/**
- * Unlock the BW vault with a master password and return the session token
- * in-memory only. Caller passes the returned session to subsequent calls;
- * we never write to BW_SESSION env or persist it to disk.
- */
-export async function unlockWithPassword(password: string, options: { runner?: Runner } = {}): Promise<BwUnlockResult> {
-  const run = options.runner ?? defaultRunner;
-  const which = run("bw", ["--version"]);
-  if (which.status !== 0) {
-    return { ok: false, error: "Bitwarden CLI ('bw') not found in PATH. Install: https://bitwarden.com/help/cli/" };
-  }
-  // `bw unlock --raw` reads the password from stdin and prints the session
-  // token to stdout. Exit code != 0 on wrong password.
-  const res = run("bw", ["unlock", "--raw", "--passwordenv", "BW_PASSWORD_PIPE"]);
-  // Fallback to stdin if --passwordenv isn't supported by this bw version.
-  if (res.status !== 0) {
-    const r2 = spawnSync("bw", ["unlock", "--raw"], { encoding: "utf8", input: `${password}\n` });
-    if (r2.status !== 0) {
-      const msg = (r2.stderr || r2.stdout || "").trim();
-      return { ok: false, error: `bw unlock failed: ${msg || "wrong master password?"}` };
-    }
-    return { ok: true, session: r2.stdout.trim() };
-  }
-  return { ok: true, session: res.stdout.trim() };
-}
-
-export interface BwListedNote {
-  name: string;
-  notes: string;
-}
-
-/**
- * List Secure Notes whose name starts with `prefix`. Used by the in-TUI
- * sync flow to discover which providers have keys stored in the vault.
- */
-export async function listSecureNotesByPrefix(
-  session: string,
-  prefix: string,
-  options: { runner?: Runner } = {},
-): Promise<{ ok: true; items: BwListedNote[] } | { ok: false; error: string }> {
-  const run = options.runner ?? defaultRunner;
-  const unlock = ensureUnlocked(session, run);
-  if (!unlock.ok) return { ok: false, error: unlock.error };
-  const list = run("bw", ["list", "items", "--search", prefix, "--session", session]);
-  if (list.status !== 0) {
-    return { ok: false, error: `bw list failed: ${list.stderr || list.stdout}` };
-  }
-  let items: BwListItem[];
-  try {
-    items = JSON.parse(list.stdout) as BwListItem[];
-  } catch {
-    return { ok: false, error: "bw list returned non-JSON output" };
-  }
-  const matched = items
-    .filter((it) => it.type === 2 && it.name.startsWith(prefix) && typeof it.notes === "string")
-    .map((it) => ({ name: it.name, notes: it.notes as string }));
-  return { ok: true, items: matched };
-}

package/src/cli/config/__tests__/model-picker.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { PickerModel } from "../model-picker.js";
-import { filterModels, groupModels } from "../model-picker.js";
-
-const SAMPLE: PickerModel[] = [
-  { id: "claude-opus-4-7", displayName: "claude-opus-4-7", provider: "anthropic", tier: "premium", capability: "text" },
-  { id: "gpt-4o", displayName: "gpt-4o", provider: "openai", tier: "premium", capability: "text" },
-  { id: "gpt-4-vision", displayName: "gpt-4-vision", provider: "openai", tier: "premium", capability: "vision" },
-  { id: "FLUX.1", displayName: "FLUX.1", provider: "siliconflow", capability: "image" },
-  { id: "deepseek-v3", displayName: "deepseek-v3", provider: "deepseek", tier: "balanced", capability: "text" },
-];
-
-describe("filterModels", () => {
-  it("returns all models when query is empty", () => {
-    expect(filterModels(SAMPLE, "")).toHaveLength(5);
-  });
-  it("filters by id substring (case-insensitive)", () => {
-    const result = filterModels(SAMPLE, "gpt");
-    expect(result).toHaveLength(2);
-    expect(result.every((m) => m.id.toLowerCase().includes("gpt"))).toBe(true);
-  });
-  it("filters by provider", () => {
-    const result = filterModels(SAMPLE, "anthropic");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.id).toBe("claude-opus-4-7");
-  });
-  it("returns empty when no match", () => {
-    expect(filterModels(SAMPLE, "zzz")).toHaveLength(0);
-  });
-  it("filters by tier", () => {
-    const result = filterModels(SAMPLE, "balanced");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.id).toBe("deepseek-v3");
-  });
-});
-
-describe("groupModels", () => {
-  it("puts vision capability models into Vision group", () => {
-    const groups = groupModels(SAMPLE);
-    const visionGroup = groups.find((g) => g.name === "Vision / Multimodal");
-    expect(visionGroup?.models).toHaveLength(1);
-    expect(visionGroup?.models[0]?.id).toBe("gpt-4-vision");
-  });
-  it("puts image capability models into Image group", () => {
-    const groups = groupModels(SAMPLE);
-    const imageGroup = groups.find((g) => g.name === "Image Generation");
-    expect(imageGroup?.models).toHaveLength(1);
-  });
-  it("puts text capability models into Text / Chat group", () => {
-    const groups = groupModels(SAMPLE);
-    const textGroup = groups.find((g) => g.name === "Text / Chat");
-    expect(textGroup?.models).toHaveLength(3);
-  });
-  it("omits groups with no models", () => {
-    const textOnly = SAMPLE.filter((m) => m.capability === "text");
-    const groups = groupModels(textOnly);
-    expect(groups.every((g) => g.models.length > 0)).toBe(true);
-  });
-});

package/src/cli/config/__tests__/provider-fetch.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { inferCapability } from "../provider-fetch.js";
-
-describe("inferCapability", () => {
-  it("returns vision for model IDs containing 'vision'", () => {
-    expect(inferCapability("gpt-4-vision-preview")).toBe("vision");
-  });
-  it("returns vision for 'vl' substring", () => {
-    expect(inferCapability("Qwen2-VL-7B")).toBe("vision");
-  });
-  it("returns vision for 'multimodal'", () => {
-    expect(inferCapability("gemini-multimodal-pro")).toBe("vision");
-  });
-  it("returns image for 'flux'", () => {
-    expect(inferCapability("black-forest-labs/FLUX.1")).toBe("image");
-  });
-  it("returns image for 'dall-e'", () => {
-    expect(inferCapability("dall-e-3")).toBe("image");
-  });
-  it("returns image for 'stable-diffusion'", () => {
-    expect(inferCapability("stable-diffusion-xl")).toBe("image");
-  });
-  it("returns image for 'imagen'", () => {
-    expect(inferCapability("imagen-3")).toBe("image");
-  });
-  it("returns video for 'wan'", () => {
-    expect(inferCapability("wan-video-14b")).toBe("video");
-  });
-  it("returns video for 'kling'", () => {
-    expect(inferCapability("kling-v1")).toBe("video");
-  });
-  it("returns text for unknown model", () => {
-    expect(inferCapability("deepseek-v3")).toBe("text");
-  });
-  it("returns text for claude models", () => {
-    expect(inferCapability("claude-opus-4-7")).toBe("text");
-  });
-});

package/src/cli/config/index.ts

@@ -1,112 +0,0 @@
-import { Command } from "commander";
-import { loadCatalog } from "../../models/registry.js";
-import { listStoredProviders } from "../../providers/keychain.js";
-import { getDisabledProviders, getRoleModels } from "../../utils/settings.js";
-import { runCouncilScreen } from "./screen-council.js";
-import { runProviderScreen } from "./screen-providers.js";
-// screen-models.ts (per-model enable grid) is intentionally not wired into
-// the menu anymore — the splash now exposes provider-only selection and the
-// router auto-picks the model. The file is kept on disk so any code that
-// imports its named exports compiles.
-import { A, captureKey, enterRawMode } from "./tui.js";
-
-const MENU_ITEMS = [
-  {
-    id: "providers",
-    label: "Providers",
-    badge: async () => {
-      const stored = await listStoredProviders();
-      const disabled = getDisabledProviders();
-      const enabled = stored.filter((p) => !disabled.includes(p));
-      return `${enabled.length} enabled`;
-    },
-  },
-  {
-    id: "council",
-    label: "Council/Debate",
-    badge: async () => {
-      const roles = getRoleModels();
-      const count = Object.keys(roles).length;
-      return count > 0 ? `${count} role${count > 1 ? "s" : ""} set` : "no roles set";
-    },
-  },
-];
-
-async function runConfigMenu(): Promise<void> {
-  const W = Math.min(process.stdout.columns ?? 72, 56);
-  let cursor = 0;
-
-  const badges = await Promise.all(MENU_ITEMS.map((item) => item.badge()));
-
-  const restore = enterRawMode();
-
-  const render = () => {
-    process.stdout.write(A.CLEAR_SCREEN);
-    const lines: string[] = [];
-    const headerPad = "─".repeat(Math.max(0, W - 17));
-    lines.push(`${A.BOLD}┌─ Configuration ${headerPad}┐${A.RESET}`);
-    for (let i = 0; i < MENU_ITEMS.length; i++) {
-      const item = MENU_ITEMS[i]!;
-      const selected = i === cursor;
-      const prefix = selected ? `│  ${A.REVERSE}> ` : "│    ";
-      const suffix = selected ? A.RESET : "";
-      const badge = badges[i] ? `  ${A.DIM}[${badges[i]}]${A.RESET}` : "";
-      lines.push(`${prefix}${item.label.padEnd(18)}${badge}${suffix}`);
-    }
-    lines.push(`${A.BOLD}└${"─".repeat(W - 1)}┘${A.RESET}`);
-    lines.push("");
-    lines.push(`${A.DIM}[↑↓] navigate  [Enter] open  [q] quit${A.RESET}`);
-    process.stdout.write(lines.join("\n"));
-  };
-
-  try {
-    while (true) {
-      render();
-      const key = await captureKey();
-
-      if (key.name === "q" || key.name === "escape") break;
-      if (key.name === "up") {
-        cursor = Math.max(0, cursor - 1);
-        continue;
-      }
-      if (key.name === "down") {
-        cursor = Math.min(MENU_ITEMS.length - 1, cursor + 1);
-        continue;
-      }
-
-      if (key.name === "return") {
-        const item = MENU_ITEMS[cursor];
-        if (!item) continue;
-        restore();
-
-        if (item.id === "providers") {
-          await runProviderScreen();
-        } else if (item.id === "council") {
-          await runCouncilScreen();
-        }
-
-        const newBadges = await Promise.all(MENU_ITEMS.map((mi) => mi.badge()));
-        badges.splice(0, badges.length, ...newBadges);
-        enterRawMode();
-      }
-    }
-  } finally {
-    restore();
-    process.stdout.write("\n");
-  }
-}
-
-export function buildConfigCommand(): Command {
-  return new Command("config").description("Interactive provider and council configuration").action(async () => {
-    if (!process.stdin.isTTY) {
-      console.error("muonroi-cli config requires an interactive terminal (TTY).");
-      process.exit(1);
-    }
-    // Populate MODELS registry — the picker reads from it, and `muonroi-cli config`
-    // does not go through the main entrypoint that boots the catalog.
-    await loadCatalog().catch(() => {
-      // Picker handles empty registry gracefully (shows no rows) — surface no error here.
-    });
-    await runConfigMenu();
-  });
-}

package/src/cli/config/model-picker.ts

@@ -1,193 +0,0 @@
-import { MODELS } from "../../models/registry.js";
-import type { ModelInfo } from "../../types/index.js";
-import type { LiveModel, ModelCapability } from "./provider-fetch.js";
-import { A, captureKey, divider, enterRawMode } from "./tui.js";
-
-export interface PickerModel {
-  id: string;
-  displayName: string;
-  provider: string;
-  tier?: string;
-  capability: ModelCapability;
-}
-
-export interface ModelGroup {
-  name: string;
-  models: PickerModel[];
-}
-
-const CAPABILITY_ORDER: ModelCapability[] = ["text", "vision", "image", "video"];
-const GROUP_NAMES: Record<ModelCapability, string> = {
-  text: "Text / Chat",
-  vision: "Vision / Multimodal",
-  image: "Image Generation",
-  video: "Video Generation",
-};
-
-function modelInfoToPickerModel(m: ModelInfo): PickerModel {
-  const capability: ModelCapability = m.supportsVision ? "vision" : "text";
-  return {
-    id: m.id,
-    displayName: m.name ?? m.id,
-    provider: m.provider ?? "unknown",
-    tier: m.tier,
-    capability,
-  };
-}
-
-function liveModelToPickerModel(m: LiveModel & { provider: string }): PickerModel {
-  return {
-    id: m.id,
-    displayName: m.displayName,
-    provider: m.provider,
-    capability: m.capability,
-  };
-}
-
-export function filterModels(models: PickerModel[], query: string): PickerModel[] {
-  if (!query) return models;
-  const q = query.toLowerCase();
-  return models.filter(
-    (m) =>
-      m.id.toLowerCase().includes(q) ||
-      m.provider.toLowerCase().includes(q) ||
-      (m.tier?.toLowerCase().includes(q) ?? false),
-  );
-}
-
-export function groupModels(models: PickerModel[]): ModelGroup[] {
-  const byCapability = new Map<ModelCapability, PickerModel[]>();
-  for (const m of models) {
-    const list = byCapability.get(m.capability) ?? [];
-    list.push(m);
-    byCapability.set(m.capability, list);
-  }
-  return CAPABILITY_ORDER.filter((cap) => (byCapability.get(cap)?.length ?? 0) > 0).map((cap) => ({
-    name: GROUP_NAMES[cap],
-    models: byCapability.get(cap)!,
-  }));
-}
-
-function flattenGroups(groups: ModelGroup[]): Array<PickerModel | { groupHeader: string }> {
-  const flat: Array<PickerModel | { groupHeader: string }> = [];
-  for (const g of groups) {
-    flat.push({ groupHeader: g.name });
-    for (const m of g.models) flat.push(m);
-  }
-  return flat;
-}
-
-function countSelectables(flat: Array<PickerModel | { groupHeader: string }>): number {
-  return flat.filter((f) => !("groupHeader" in f)).length;
-}
-
-function renderPickerScreen(
-  forRole: string,
-  query: string,
-  flat: Array<PickerModel | { groupHeader: string }>,
-  cursorIdx: number,
-  fetchStatus: string,
-  width: number,
-): string {
-  const lines: string[] = [];
-  lines.push(`${A.BOLD}Select model for: ${forRole}${A.RESET}`);
-  lines.push(divider(width));
-  lines.push(`Filter: [/${query.padEnd(Math.max(0, width - 10))}]`);
-  lines.push("");
-
-  let selectable = -1;
-  for (const item of flat) {
-    if ("groupHeader" in item) {
-      lines.push(`${A.DIM}${item.groupHeader}${A.RESET}`);
-    } else {
-      selectable++;
-      const selected = selectable === cursorIdx;
-      const prefix = selected ? `${A.REVERSE}> ` : "  ";
-      const suffix = selected ? A.RESET : "";
-      const tier = item.tier ? `  ${A.DIM}${item.tier}${A.RESET}` : "";
-      const provider = `${A.DIM}${item.provider}${A.RESET}`;
-      lines.push(`${prefix}${item.displayName.padEnd(32)} ${provider}${tier}${suffix}`);
-    }
-  }
-
-  if (fetchStatus) {
-    lines.push("");
-    lines.push(`${A.DIM}${fetchStatus}${A.RESET}`);
-  }
-  lines.push("");
-  lines.push(`${A.DIM}[↑↓] navigate  [Enter] select  [Esc] cancel${A.RESET}`);
-  return lines.join("\n");
-}
-
-export async function openModelPicker(
-  forRole: string,
-  extraModels: Array<LiveModel & { provider: string }> = [],
-): Promise<string | null> {
-  const catalogModels = MODELS.map(modelInfoToPickerModel);
-  const liveModels = extraModels.map(liveModelToPickerModel);
-
-  const catalogIds = new Set(catalogModels.map((m) => m.id));
-  const merged = [...catalogModels, ...liveModels.filter((m) => !catalogIds.has(m.id))];
-
-  const W = Math.min(process.stdout.columns ?? 72, 80);
-  let query = "";
-  let cursorIdx = 0;
-  const fetchStatus = "";
-
-  const restore = enterRawMode();
-
-  const getFlat = () => {
-    const filtered = filterModels(merged, query);
-    const groups = groupModels(filtered);
-    return flattenGroups(groups);
-  };
-
-  const render = () => {
-    const flat = getFlat();
-    const selectableCount = countSelectables(flat);
-    cursorIdx = Math.max(0, Math.min(cursorIdx, selectableCount - 1));
-    process.stdout.write(A.CLEAR_SCREEN);
-    process.stdout.write(renderPickerScreen(forRole, query, flat, cursorIdx, fetchStatus, W));
-  };
-
-  try {
-    while (true) {
-      render();
-      const key = await captureKey();
-
-      if (key.name === "escape") return null;
-
-      if (key.name === "up") {
-        cursorIdx = Math.max(0, cursorIdx - 1);
-        continue;
-      }
-
-      if (key.name === "down") {
-        const flat = getFlat();
-        cursorIdx = Math.min(countSelectables(flat) - 1, cursorIdx + 1);
-        continue;
-      }
-
-      if (key.name === "backspace") {
-        query = query.slice(0, -1);
-        cursorIdx = 0;
-        continue;
-      }
-
-      if (key.name === "return") {
-        const flat = getFlat();
-        const selectables = flat.filter((f): f is PickerModel => !("groupHeader" in f));
-        const chosen = selectables[cursorIdx];
-        if (chosen) return chosen.id;
-        continue;
-      }
-
-      if (key.name.length === 1 && key.name >= " ") {
-        query += key.name;
-        cursorIdx = 0;
-      }
-    }
-  } finally {
-    restore();
-  }
-}

package/src/cli/config/provider-fetch.ts

@@ -1,75 +0,0 @@
-import * as http from "node:http";
-import * as https from "node:https";
-
-export type ModelCapability = "text" | "vision" | "image" | "video";
-
-export interface LiveModel {
-  id: string;
-  displayName: string;
-  capability: ModelCapability;
-}
-
-const VISION_RE = /vision|vl|multimodal/i;
-const IMAGE_RE = /flux|stable[_-]diffusion|imagen|dall[_-]e/i;
-const VIDEO_RE = /video|wan[_-]|kling|hailuo/i;
-
-export function inferCapability(modelId: string): ModelCapability {
-  const id = modelId.toLowerCase();
-  if (VISION_RE.test(id)) return "vision";
-  if (IMAGE_RE.test(id)) return "image";
-  if (VIDEO_RE.test(id)) return "video";
-  return "text";
-}
-
-function shortName(id: string): string {
-  const slash = id.lastIndexOf("/");
-  return slash >= 0 ? id.slice(slash + 1) : id;
-}
-
-export async function fetchProviderModels(baseURL: string, apiKey: string, timeoutMs = 8000): Promise<LiveModel[]> {
-  const url = new URL("/v1/models", baseURL.endsWith("/") ? baseURL : `${baseURL}/`);
-  const lib = url.protocol === "https:" ? https : http;
-
-  return new Promise((resolve) => {
-    const req = lib.get(
-      url.toString(),
-      {
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          Accept: "application/json",
-        },
-        timeout: timeoutMs,
-      },
-      (res) => {
-        let body = "";
-        res.on("data", (chunk: Buffer) => {
-          body += chunk.toString();
-        });
-        res.on("end", () => {
-          try {
-            const json = JSON.parse(body) as {
-              data?: Array<{ id: string }>;
-            };
-            const items = json.data ?? [];
-            resolve(
-              items
-                .filter((m) => typeof m.id === "string")
-                .map((m) => ({
-                  id: m.id,
-                  displayName: shortName(m.id),
-                  capability: inferCapability(m.id),
-                })),
-            );
-          } catch {
-            resolve([]);
-          }
-        });
-      },
-    );
-    req.on("error", () => resolve([]));
-    req.on("timeout", () => {
-      req.destroy();
-      resolve([]);
-    });
-  });
-}