@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/remote-questions/format.ts

@@ -0,0 +1,163 @@
+/**
+ * Remote Questions — payload formatting and parsing helpers
+ */
+
+import type { RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
+
+export interface SlackBlock {
+  type: string;
+  text?: { type: string; text: string };
+  elements?: Array<{ type: string; text: string }>;
+}
+
+export interface DiscordEmbed {
+  title: string;
+  description: string;
+  color: number;
+  fields: Array<{ name: string; value: string; inline?: boolean }>;
+  footer?: { text: string };
+}
+
+const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+const MAX_USER_NOTE_LENGTH = 500;
+
+export function formatForSlack(prompt: RemotePrompt): SlackBlock[] {
+  const blocks: SlackBlock[] = [
+    {
+      type: "header",
+      text: { type: "plain_text", text: "GSD needs your input" },
+    },
+  ];
+
+  for (const q of prompt.questions) {
+    blocks.push({
+      type: "section",
+      text: { type: "mrkdwn", text: `*${q.header}*\n${q.question}` },
+    });
+
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: q.options.map((opt, i) => `${i + 1}. *${opt.label}* — ${opt.description}`).join("\n"),
+      },
+    });
+
+    blocks.push({
+      type: "context",
+      elements: [{
+        type: "mrkdwn",
+        text: q.allowMultiple
+          ? "Reply in thread with comma-separated numbers (`1,3`) or free text."
+          : "Reply in thread with a number (`1`) or free text.",
+      }],
+    });
+
+    blocks.push({ type: "divider" });
+  }
+
+  return blocks;
+}
+
+export function formatForDiscord(prompt: RemotePrompt): { embeds: DiscordEmbed[]; reactionEmojis: string[] } {
+  const reactionEmojis: string[] = [];
+  const embeds: DiscordEmbed[] = prompt.questions.map((q, questionIndex) => {
+    const supportsReactions = prompt.questions.length === 1;
+    const optionLines = q.options.map((opt, i) => {
+      const emoji = NUMBER_EMOJIS[i] ?? `${i + 1}.`;
+      if (supportsReactions && NUMBER_EMOJIS[i]) reactionEmojis.push(NUMBER_EMOJIS[i]);
+      return `${emoji} **${opt.label}** — ${opt.description}`;
+    });
+
+    const footerText = supportsReactions
+      ? (q.allowMultiple
+          ? "Reply with comma-separated choices (`1,3`) or react with matching numbers"
+          : "Reply with a number or react with the matching number")
+      : `Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`;
+
+    return {
+      title: q.header,
+      description: q.question,
+      color: 0x7c3aed,
+      fields: [{ name: "Options", value: optionLines.join("\n") }],
+      footer: { text: footerText },
+    };
+  });
+
+  return { embeds, reactionEmojis };
+}
+
+export function parseSlackReply(text: string, questions: RemoteQuestion[]): RemoteAnswer {
+  const answers: RemoteAnswer["answers"] = {};
+  const trimmed = text.trim();
+
+  if (questions.length === 1) {
+    answers[questions[0].id] = parseAnswerForQuestion(trimmed, questions[0]);
+    return { answers };
+  }
+
+  const parts = trimmed.includes(";")
+    ? trimmed.split(";").map((s) => s.trim()).filter(Boolean)
+    : trimmed.split("\n").map((s) => s.trim()).filter(Boolean);
+
+  for (let i = 0; i < questions.length; i++) {
+    answers[questions[i].id] = parseAnswerForQuestion(parts[i] ?? "", questions[i]);
+  }
+
+  return { answers };
+}
+
+export function parseDiscordResponse(
+  reactions: Array<{ emoji: string; count: number }>,
+  replyText: string | null,
+  questions: RemoteQuestion[],
+): RemoteAnswer {
+  if (replyText) return parseSlackReply(replyText, questions);
+
+  const answers: RemoteAnswer["answers"] = {};
+  if (questions.length !== 1) {
+    for (const q of questions) {
+      answers[q.id] = { answers: [], user_note: "Discord reactions are only supported for single-question prompts" };
+    }
+    return { answers };
+  }
+
+  const q = questions[0];
+  const picked = reactions
+    .filter((r) => NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
+    .map((r) => q.options[NUMBER_EMOJIS.indexOf(r.emoji)]?.label)
+    .filter(Boolean) as string[];
+
+  answers[q.id] = picked.length > 0
+    ? { answers: q.allowMultiple ? picked : [picked[0]] }
+    : { answers: [], user_note: "No clear response via reactions" };
+
+  return { answers };
+}
+
+function parseAnswerForQuestion(text: string, q: RemoteQuestion): { answers: string[]; user_note?: string } {
+  if (!text) return { answers: [], user_note: "No response provided" };
+
+  if (/^[\d,\s]+$/.test(text)) {
+    const nums = text
+      .split(",")
+      .map((s) => parseInt(s.trim(), 10))
+      .filter((n) => !Number.isNaN(n) && n >= 1 && n <= q.options.length);
+
+    if (nums.length > 0) {
+      const selected = nums.map((n) => q.options[n - 1].label);
+      return { answers: q.allowMultiple ? selected : [selected[0]] };
+    }
+  }
+
+  const single = parseInt(text, 10);
+  if (!Number.isNaN(single) && single >= 1 && single <= q.options.length) {
+    return { answers: [q.options[single - 1].label] };
+  }
+
+  return { answers: [], user_note: truncateNote(text) };
+}
+
+function truncateNote(text: string): string {
+  return text.length > MAX_USER_NOTE_LENGTH ? text.slice(0, MAX_USER_NOTE_LENGTH) + "…" : text;
+}

package/src/resources/extensions/remote-questions/manager.ts

@@ -0,0 +1,192 @@
+/**
+ * Remote Questions — orchestration manager
+ */
+
+import { randomUUID } from "node:crypto";
+import type { ChannelAdapter, RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
+import { resolveRemoteConfig, type ResolvedConfig } from "./config.js";
+import { SlackAdapter } from "./slack-adapter.js";
+import { DiscordAdapter } from "./discord-adapter.js";
+import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
+
+interface ToolResult {
+  content: Array<{ type: "text"; text: string }>;
+  details?: Record<string, unknown>;
+}
+
+interface QuestionInput {
+  id: string;
+  header: string;
+  question: string;
+  options: Array<{ label: string; description: string }>;
+  allowMultiple?: boolean;
+}
+
+export async function tryRemoteQuestions(
+  questions: QuestionInput[],
+  signal?: AbortSignal,
+): Promise<ToolResult | null> {
+  const config = resolveRemoteConfig();
+  if (!config) return null;
+
+  const prompt = createPrompt(questions, config);
+  writePromptRecord(createPromptRecord(prompt));
+
+  const adapter = createAdapter(config);
+  try {
+    await adapter.validate();
+  } catch (err) {
+    markPromptStatus(prompt.id, "failed", sanitizeError(String((err as Error).message)));
+    return errorResult(`Remote auth failed (${config.channel}): ${(err as Error).message}`, config.channel);
+  }
+
+  let dispatch;
+  try {
+    dispatch = await adapter.sendPrompt(prompt);
+    markPromptDispatched(prompt.id, dispatch.ref);
+  } catch (err) {
+    markPromptStatus(prompt.id, "failed", sanitizeError(String((err as Error).message)));
+    return errorResult(`Failed to send questions via ${config.channel}: ${(err as Error).message}`, config.channel);
+  }
+
+  const answer = await pollUntilDone(adapter, prompt, dispatch.ref, signal);
+  if (!answer) {
+    markPromptStatus(prompt.id, signal?.aborted ? "cancelled" : "timed_out");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          timed_out: true,
+          channel: config.channel,
+          prompt_id: prompt.id,
+          timeout_minutes: config.timeoutMs / 60000,
+          thread_url: dispatch.ref.threadUrl ?? null,
+          message: `User did not respond within ${config.timeoutMs / 60000} minutes.`,
+        }),
+      }],
+      details: {
+        remote: true,
+        channel: config.channel,
+        timed_out: true,
+        promptId: prompt.id,
+        threadUrl: dispatch.ref.threadUrl,
+        status: signal?.aborted ? "cancelled" : "timed_out",
+      },
+    };
+  }
+
+  markPromptAnswered(prompt.id, answer);
+  return {
+    content: [{ type: "text", text: JSON.stringify({ answers: formatForTool(answer) }) }],
+    details: {
+      remote: true,
+      channel: config.channel,
+      timed_out: false,
+      promptId: prompt.id,
+      threadUrl: dispatch.ref.threadUrl,
+      questions,
+      response: answer,
+      status: "answered",
+    },
+  };
+}
+
+function createPrompt(questions: QuestionInput[], config: ResolvedConfig): RemotePrompt {
+  const createdAt = Date.now();
+  return {
+    id: randomUUID(),
+    channel: config.channel,
+    createdAt,
+    timeoutAt: createdAt + config.timeoutMs,
+    pollIntervalMs: config.pollIntervalMs,
+    context: { source: "ask_user_questions" },
+    questions: questions.map((q): RemoteQuestion => ({
+      id: q.id,
+      header: q.header,
+      question: q.question,
+      options: q.options,
+      allowMultiple: q.allowMultiple ?? false,
+    })),
+  };
+}
+
+function createAdapter(config: ResolvedConfig): ChannelAdapter {
+  return config.channel === "slack"
+    ? new SlackAdapter(config.token, config.channelId)
+    : new DiscordAdapter(config.token, config.channelId);
+}
+
+async function pollUntilDone(
+  adapter: ChannelAdapter,
+  prompt: RemotePrompt,
+  ref: import("./types.js").RemotePromptRef,
+  signal?: AbortSignal,
+): Promise<RemoteAnswer | null> {
+  let retryCount = 0;
+  while (Date.now() < prompt.timeoutAt && !signal?.aborted) {
+    try {
+      const answer = await adapter.pollAnswer(prompt, ref);
+      updatePromptRecord(prompt.id, { lastPollAt: Date.now() });
+      retryCount = 0;
+      if (answer) return answer;
+    } catch (err) {
+      retryCount++;
+      if (retryCount > 1) {
+        markPromptStatus(prompt.id, "failed", sanitizeError(String((err as Error).message)));
+        return null;
+      }
+    }
+
+    await sleep(prompt.pollIntervalMs, signal);
+  }
+
+  return null;
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const timer = setTimeout(() => {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function formatForTool(answer: RemoteAnswer): Record<string, { answers: string[] }> {
+  const out: Record<string, { answers: string[] }> = {};
+  for (const [id, data] of Object.entries(answer.answers)) {
+    const list = [...data.answers];
+    if (data.user_note) list.push(`user_note: ${data.user_note}`);
+    out[id] = { answers: list };
+  }
+  return out;
+}
+
+// Strip token-like strings from error messages before surfacing
+const TOKEN_PATTERNS = [
+  /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
+  /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
+  /xoxa-[A-Za-z0-9\-]+/g,    // Slack app tokens
+  /[A-Za-z0-9_\-.]{20,}/g,   // Long opaque secrets (Discord tokens, etc.)
+];
+
+export function sanitizeError(msg: string): string {
+  let sanitized = msg;
+  for (const pattern of TOKEN_PATTERNS) {
+    sanitized = sanitized.replace(pattern, "[REDACTED]");
+  }
+  return sanitized;
+}
+
+function errorResult(message: string, channel: string): ToolResult {
+  return {
+    content: [{ type: "text", text: sanitizeError(message) }],
+    details: { remote: true, channel, error: true, status: "failed" },
+  };
+}

package/src/resources/extensions/remote-questions/remote-command.ts

@@ -0,0 +1,307 @@
+/**
+ * Remote Questions — /gsd remote command
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
+import { sanitizeError } from "./manager.js";
+import { getLatestPromptSummary } from "./status.js";
+
+export async function handleRemote(
+  subcommand: string,
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+): Promise<void> {
+  const trimmed = subcommand.trim();
+
+  if (trimmed === "slack") return handleSetupSlack(ctx);
+  if (trimmed === "discord") return handleSetupDiscord(ctx);
+  if (trimmed === "status") return handleRemoteStatus(ctx);
+  if (trimmed === "disconnect") return handleDisconnect(ctx);
+
+  return handleRemoteMenu(ctx);
+}
+
+async function handleSetupSlack(ctx: ExtensionCommandContext): Promise<void> {
+  const token = await promptMaskedInput(ctx, "Slack Bot Token", "Paste your xoxb-... token");
+  if (!token) return void ctx.ui.notify("Slack setup cancelled.", "info");
+  if (!token.startsWith("xoxb-")) return void ctx.ui.notify("Invalid token format — Slack bot tokens start with xoxb-.", "warning");
+
+  ctx.ui.notify("Validating token...", "info");
+  const auth = await fetchJson("https://slack.com/api/auth.test", { headers: { Authorization: `Bearer ${token}` } });
+  if (!auth?.ok) return void ctx.ui.notify("Token validation failed — check the token and app install.", "error");
+
+  const channelId = await promptInput(ctx, "Channel ID", "Paste the Slack channel ID (e.g. C0123456789)");
+  if (!channelId) return void ctx.ui.notify("Slack setup cancelled.", "info");
+  if (!isValidChannelId("slack", channelId)) return void ctx.ui.notify("Invalid Slack channel ID format — expected 9-12 uppercase alphanumeric characters.", "error");
+
+  const send = await fetchJson("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+    body: JSON.stringify({ channel: channelId, text: "GSD remote questions connected." }),
+  });
+  if (!send?.ok) return void ctx.ui.notify(`Could not send to channel: ${send?.error ?? "unknown error"}`, "error");
+
+  saveProviderToken("slack_bot", token);
+  process.env.SLACK_BOT_TOKEN = token;
+  saveRemoteQuestionsConfig("slack", channelId);
+  ctx.ui.notify(`Slack connected — remote questions enabled for channel ${channelId}.`, "info");
+}
+
+async function handleSetupDiscord(ctx: ExtensionCommandContext): Promise<void> {
+  const token = await promptMaskedInput(ctx, "Discord Bot Token", "Paste your bot token");
+  if (!token) return void ctx.ui.notify("Discord setup cancelled.", "info");
+
+  ctx.ui.notify("Validating token...", "info");
+  const auth = await fetchJson("https://discord.com/api/v10/users/@me", { headers: { Authorization: `Bot ${token}` } });
+  if (!auth?.id) return void ctx.ui.notify("Token validation failed — check the bot token.", "error");
+
+  const channelId = await promptInput(ctx, "Channel ID", "Paste the Discord channel ID (e.g. 1234567890123456789)");
+  if (!channelId) return void ctx.ui.notify("Discord setup cancelled.", "info");
+  if (!isValidChannelId("discord", channelId)) return void ctx.ui.notify("Invalid Discord channel ID format — expected 17-20 digit numeric ID.", "error");
+
+  const sendResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: { Authorization: `Bot ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ content: "GSD remote questions connected." }),
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!sendResponse.ok) {
+    const body = await sendResponse.text().catch(() => "");
+    return void ctx.ui.notify(`Could not send to channel (HTTP ${sendResponse.status}): ${sanitizeError(body).slice(0, 200)}`, "error");
+  }
+
+  saveProviderToken("discord_bot", token);
+  process.env.DISCORD_BOT_TOKEN = token;
+  saveRemoteQuestionsConfig("discord", channelId);
+  ctx.ui.notify(`Discord connected — remote questions enabled for channel ${channelId}.`, "info");
+}
+
+async function handleRemoteStatus(ctx: ExtensionCommandContext): Promise<void> {
+  const status = getRemoteConfigStatus();
+  const config = resolveRemoteConfig();
+  if (!config) {
+    ctx.ui.notify(status, status.includes("disabled") ? "warning" : "info");
+    return;
+  }
+
+  const latestPrompt = getLatestPromptSummary();
+  const lines = [status];
+  if (latestPrompt) {
+    lines.push(`Last prompt: ${latestPrompt.id}`);
+    lines.push(`  status: ${latestPrompt.status}`);
+    if (latestPrompt.updatedAt) lines.push(`  updated: ${new Date(latestPrompt.updatedAt).toLocaleString()}`);
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function handleDisconnect(ctx: ExtensionCommandContext): Promise<void> {
+  const prefs = loadEffectiveGSDPreferences();
+  const channel = prefs?.preferences.remote_questions?.channel;
+  if (!channel) return void ctx.ui.notify("No remote channel configured — nothing to disconnect.", "info");
+
+  removeRemoteQuestionsConfig();
+  removeProviderToken(channel === "slack" ? "slack_bot" : "discord_bot");
+  if (channel === "slack") delete process.env.SLACK_BOT_TOKEN;
+  if (channel === "discord") delete process.env.DISCORD_BOT_TOKEN;
+  ctx.ui.notify(`Remote questions disconnected (${channel}).`, "info");
+}
+
+async function handleRemoteMenu(ctx: ExtensionCommandContext): Promise<void> {
+  const config = resolveRemoteConfig();
+  const latestPrompt = getLatestPromptSummary();
+  const lines = config
+    ? [
+        `Remote questions: ${config.channel} configured`,
+        `  Timeout: ${config.timeoutMs / 60000}m, poll: ${config.pollIntervalMs / 1000}s`,
+        latestPrompt ? `  Last prompt: ${latestPrompt.id} (${latestPrompt.status})` : "  No remote prompts recorded yet",
+        "",
+        "Commands:",
+        "  /gsd remote status",
+        "  /gsd remote disconnect",
+        "  /gsd remote slack",
+        "  /gsd remote discord",
+      ]
+    : [
+        "No remote question channel configured.",
+        "",
+        "Commands:",
+        "  /gsd remote slack",
+        "  /gsd remote discord",
+        "  /gsd remote status",
+      ];
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function fetchJson(url: string, init?: RequestInit): Promise<any> {
+  try {
+    const response = await fetch(url, { ...init, signal: AbortSignal.timeout(15_000) });
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+function getAuthStorage(): AuthStorage {
+  const authPath = join(process.env.HOME ?? "", ".gsd", "agent", "auth.json");
+  mkdirSync(dirname(authPath), { recursive: true });
+  return AuthStorage.create(authPath);
+}
+
+function saveProviderToken(provider: string, token: string): void {
+  const auth = getAuthStorage();
+  auth.set(provider, { type: "api_key", key: token });
+}
+
+function removeProviderToken(provider: string): void {
+  const auth = getAuthStorage();
+  auth.set(provider, { type: "api_key", key: "" });
+}
+
+function saveRemoteQuestionsConfig(channel: "slack" | "discord", channelId: string): void {
+  const prefsPath = getGlobalGSDPreferencesPath();
+  const block = [
+    "remote_questions:",
+    `  channel: ${channel}`,
+    `  channel_id: \"${channelId}\"`,
+    "  timeout_minutes: 5",
+    "  poll_interval_seconds: 5",
+  ].join("\n");
+
+  const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let next = content;
+
+  if (fmMatch) {
+    let frontmatter = fmMatch[1];
+    const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/;
+    frontmatter = regex.test(frontmatter) ? frontmatter.replace(regex, block) : `${frontmatter.trimEnd()}\n${block}`;
+    next = `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}`;
+  } else {
+    next = `---\n${block}\n---\n\n${content}`;
+  }
+
+  mkdirSync(dirname(prefsPath), { recursive: true });
+  writeFileSync(prefsPath, next, "utf-8");
+}
+
+function removeRemoteQuestionsConfig(): void {
+  const prefsPath = getGlobalGSDPreferencesPath();
+  if (!existsSync(prefsPath)) return;
+  const content = readFileSync(prefsPath, "utf-8");
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return;
+  const frontmatter = fmMatch[1].replace(/remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/, "").trim();
+  const next = frontmatter ? `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}` : content.slice(fmMatch[0].length).replace(/^\n+/, "");
+  writeFileSync(prefsPath, next, "utf-8");
+}
+
+function maskEditorLine(line: string): string {
+  let output = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line.startsWith(CURSOR_MARKER, i)) {
+      output += CURSOR_MARKER;
+      i += CURSOR_MARKER.length;
+      continue;
+    }
+    const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+    if (ansiMatch) {
+      output += ansiMatch[0];
+      i += ansiMatch[0].length;
+      continue;
+    }
+    output += line[i] === " " ? " " : "*";
+    i += 1;
+  }
+  return output;
+}
+
+async function promptMaskedInput(ctx: ExtensionCommandContext, label: string, hint: string): Promise<string | null> {
+  if (!ctx.hasUI) return null;
+  return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
+    let cachedLines: string[] | undefined;
+    const editorTheme: EditorTheme = {
+      borderColor: (s: string) => theme.fg("accent", s),
+      selectList: {
+        selectedPrefix: (t: string) => theme.fg("accent", t),
+        selectedText: (t: string) => theme.fg("accent", t),
+        description: (t: string) => theme.fg("muted", t),
+        scrollInfo: (t: string) => theme.fg("dim", t),
+        noMatch: (t: string) => theme.fg("warning", t),
+      },
+    };
+    const editor = new Editor(tui, editorTheme, { paddingX: 1 });
+    const refresh = () => { cachedLines = undefined; tui.requestRender(); };
+    const handleInput = (data: string) => {
+      if (matchesKey(data, Key.enter)) return done(editor.getText().trim() || null);
+      if (matchesKey(data, Key.escape)) return done(null);
+      editor.handleInput(data); refresh();
+    };
+    const render = (width: number) => {
+      if (cachedLines) return cachedLines;
+      const lines: string[] = [];
+      const add = (s: string) => lines.push(truncateToWidth(s, width));
+      add(theme.fg("accent", "─".repeat(width)));
+      add(theme.fg("accent", theme.bold(` ${label}`)));
+      add(theme.fg("muted", `  ${hint}`));
+      lines.push("");
+      add(theme.fg("muted", " Enter value:"));
+      for (const line of editor.render(width - 2)) add(theme.fg("text", maskEditorLine(line)));
+      lines.push("");
+      add(theme.fg("dim", " enter to confirm  |  esc to cancel"));
+      add(theme.fg("accent", "─".repeat(width)));
+      cachedLines = lines;
+      return lines;
+    };
+    return { render, handleInput, invalidate: () => { cachedLines = undefined; } };
+  });
+}
+
+async function promptInput(ctx: ExtensionCommandContext, label: string, hint: string): Promise<string | null> {
+  if (!ctx.hasUI) return null;
+  return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {
+    let cachedLines: string[] | undefined;
+    const editorTheme: EditorTheme = {
+      borderColor: (s: string) => theme.fg("accent", s),
+      selectList: {
+        selectedPrefix: (t: string) => theme.fg("accent", t),
+        selectedText: (t: string) => theme.fg("accent", t),
+        description: (t: string) => theme.fg("muted", t),
+        scrollInfo: (t: string) => theme.fg("dim", t),
+        noMatch: (t: string) => theme.fg("warning", t),
+      },
+    };
+    const editor = new Editor(tui, editorTheme, { paddingX: 1 });
+    const refresh = () => { cachedLines = undefined; tui.requestRender(); };
+    const handleInput = (data: string) => {
+      if (matchesKey(data, Key.enter)) return done(editor.getText().trim() || null);
+      if (matchesKey(data, Key.escape)) return done(null);
+      editor.handleInput(data); refresh();
+    };
+    const render = (width: number) => {
+      if (cachedLines) return cachedLines;
+      const lines: string[] = [];
+      const add = (s: string) => lines.push(truncateToWidth(s, width));
+      add(theme.fg("accent", "─".repeat(width)));
+      add(theme.fg("accent", theme.bold(` ${label}`)));
+      add(theme.fg("muted", `  ${hint}`));
+      lines.push("");
+      add(theme.fg("muted", " Enter value:"));
+      for (const line of editor.render(width - 2)) add(theme.fg("text", line));
+      lines.push("");
+      add(theme.fg("dim", " enter to confirm  |  esc to cancel"));
+      add(theme.fg("accent", "─".repeat(width)));
+      cachedLines = lines;
+      return lines;
+    };
+    return { render, handleInput, invalidate: () => { cachedLines = undefined; } };
+  });
+}