@firstpick/pi-package-remote-webui 0.1.0

package/index.ts

@@ -0,0 +1,284 @@
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import type { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  REMOTE_WIDGET_KEY,
+  RemoteWebuiController,
+  buildRemoteWidgetLines,
+  closeRemoteWebui,
+  formatStatus,
+  generateQrLines,
+  openRemoteWebui,
+  parseRemoteArgs,
+  requiresOpenConfirmation,
+  usage,
+} from "./lib/remote-core.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = __dirname;
+const require = createRequire(import.meta.url);
+const LOCAL_HOST = "127.0.0.1";
+
+const OPEN_WARNING = [
+  "Pi Web UI can control Pi/WebUI and run allowed tools from connected browsers.",
+  "Remote PIN auth is off by default; enable it in Web UI Controls if you want a 4-digit PIN for non-local clients.",
+  "",
+  "Only open this on a trusted local network.",
+  "",
+  "Open to local network?",
+].join("\n");
+
+type WebuiChild = ChildProcessByStdio<null, Readable, Readable>;
+
+type RemoteOptions = {
+  action: "open" | "status" | "close" | "refresh";
+  port: number;
+  name?: string;
+  yes: boolean;
+};
+
+function resolveExistingPath(candidate: string | undefined): string | undefined {
+  if (!candidate) return undefined;
+  return existsSync(candidate) ? candidate : undefined;
+}
+
+function resolveWebuiBin(): string {
+  const candidates: Array<() => string | undefined> = [
+    () => resolveExistingPath(require.resolve("@firstpick/pi-package-webui/bin/pi-webui.mjs")),
+    () => resolveExistingPath(path.join(path.dirname(require.resolve("@firstpick/pi-package-webui/package.json")), "bin", "pi-webui.mjs")),
+    () => resolveExistingPath(path.resolve(packageRoot, "..", "pi-package-webui", "bin", "pi-webui.mjs")),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      const resolved = candidate();
+      if (resolved) return resolved;
+    } catch {
+      // Try next resolution strategy.
+    }
+  }
+
+  throw new Error("Could not locate @firstpick/pi-package-webui/bin/pi-webui.mjs. Install @firstpick/pi-package-webui or run from the npm-packages checkout.");
+}
+
+function appendBoundedOutput(current: string, chunk: Buffer | string, maxChars = 20_000): string {
+  const next = current + String(chunk);
+  return next.length > maxChars ? next.slice(-maxChars) : next;
+}
+
+function releaseStartedChild(child: WebuiChild): void {
+  child.stdout.removeAllListeners("data");
+  child.stderr.removeAllListeners("data");
+  (child.stdout as Readable & { unref?: () => void }).unref?.();
+  (child.stderr as Readable & { unref?: () => void }).unref?.();
+  child.unref();
+}
+
+function terminateFailedChild(child: WebuiChild): void {
+  if (child.exitCode === null) child.kill("SIGTERM");
+  setTimeout(() => {
+    if (child.exitCode === null) child.kill("SIGKILL");
+  }, 2_000).unref?.();
+  child.stdout.destroy();
+  child.stderr.destroy();
+}
+
+async function spawnWebui(options: RemoteOptions, ctx: ExtensionCommandContext): Promise<void> {
+  const webuiBin = resolveWebuiBin();
+  const args = [webuiBin, "--host", LOCAL_HOST, "--port", String(options.port), "--cwd", ctx.cwd];
+  if (options.name) args.push("--name", options.name);
+
+  const child = spawn(process.execPath, args, {
+    cwd: ctx.cwd,
+    env: { ...process.env },
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    let output = "";
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(startedTimer);
+      child.off("error", onError);
+      child.off("exit", onExit);
+      if (error) {
+        terminateFailedChild(child);
+        reject(error);
+      } else {
+        releaseStartedChild(child);
+        resolve();
+      }
+    };
+    const onError = (error: Error) => finish(error);
+    const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
+      finish(new Error(`Pi Web UI exited before startup (${code ?? signal ?? "unknown"}). Output:\n${output.trim() || "(no output)"}`));
+    };
+
+    child.stdout.on("data", (chunk) => {
+      output = appendBoundedOutput(output, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      output = appendBoundedOutput(output, chunk);
+    });
+    child.once("error", onError);
+    child.once("exit", onExit);
+
+    // If the process survives this short preflight, the controller health poll
+    // will perform the authoritative readiness check.
+    const startedTimer = setTimeout(() => finish(), 250);
+  });
+}
+
+function setRemoteStatus(ctx: ExtensionCommandContext, text?: string): void {
+  ctx.ui.setStatus(REMOTE_WIDGET_KEY, text);
+}
+
+function clearRemoteWidget(ctx: ExtensionCommandContext): void {
+  ctx.ui.setWidget(REMOTE_WIDGET_KEY, undefined);
+}
+
+function truncatePlainLine(line: string, width: number): string {
+  if (width <= 0) return "";
+  return line.length > width ? line.slice(0, width) : line;
+}
+
+function formatWidgetLine(line: string, width: number): string {
+  if (width <= 0) return "";
+  if (width === 1) return " ";
+  return ` ${truncatePlainLine(line, width - 1)}`;
+}
+
+function setFullRemoteWidget(ctx: ExtensionCommandContext, lines: string[]): void {
+  if (ctx.mode !== "tui") {
+    ctx.ui.setWidget(REMOTE_WIDGET_KEY, lines, { placement: "aboveEditor" });
+    return;
+  }
+
+  const widgetLines = lines.map((line) => String(line ?? ""));
+  ctx.ui.setWidget(
+    REMOTE_WIDGET_KEY,
+    () => ({
+      render: (width: number) => widgetLines.map((line) => formatWidgetLine(line, width)),
+      invalidate: () => {},
+    }),
+    { placement: "aboveEditor" },
+  );
+}
+
+async function renderRemoteWidget(ctx: ExtensionCommandContext, result: { url: string; network?: unknown; started?: boolean }): Promise<void> {
+  const qrLines = await generateQrLines(result.url);
+  const lines = buildRemoteWidgetLines({ url: result.url, qrLines, network: result.network, started: result.started });
+  setFullRemoteWidget(ctx, lines);
+  setRemoteStatus(ctx, `remote ${result.url}`);
+}
+
+async function confirmRemoteOpen(options: RemoteOptions, ctx: ExtensionCommandContext): Promise<boolean> {
+  if (!requiresOpenConfirmation(options)) return true;
+  if (!ctx.hasUI) throw new Error("/remote requires confirmation. Re-run with /remote --yes in non-interactive modes.");
+  return await ctx.ui.confirm("Open Pi Web UI to LAN?", OPEN_WARNING);
+}
+
+async function handleStatus(options: RemoteOptions, ctx: ExtensionCommandContext, controller: RemoteWebuiController): Promise<void> {
+  setRemoteStatus(ctx, "checking remote webui…");
+  try {
+    const status = await controller.status(options.port);
+    ctx.ui.notify(formatStatus(status), status.online ? "info" : "warning");
+  } finally {
+    setRemoteStatus(ctx, undefined);
+  }
+}
+
+async function handleRefresh(options: RemoteOptions, ctx: ExtensionCommandContext, controller: RemoteWebuiController): Promise<void> {
+  setRemoteStatus(ctx, "refreshing remote QR…");
+  try {
+    const status = await controller.status(options.port);
+    if (!status.online) {
+      clearRemoteWidget(ctx);
+      ctx.ui.notify(`${formatStatus(status)}\n\nRun /remote to start and open it.`, "warning");
+      return;
+    }
+    if (!status.network?.open || !status.url || !/^https?:\/\//i.test(status.url)) {
+      clearRemoteWidget(ctx);
+      ctx.ui.notify(`${formatStatus(status)}\n\nRun /remote to open LAN access and show a QR code.`, "warning");
+      return;
+    }
+    await renderRemoteWidget(ctx, { url: status.url, network: status.network, started: false });
+    ctx.ui.notify(`Pi Remote WebUI QR refreshed:\n${status.url}`, "info");
+  } finally {
+    setRemoteStatus(ctx, undefined);
+  }
+}
+
+async function handleClose(options: RemoteOptions, ctx: ExtensionCommandContext, controller: RemoteWebuiController): Promise<void> {
+  setRemoteStatus(ctx, "closing remote webui…");
+  try {
+    const result = await closeRemoteWebui(options, { controller });
+    clearRemoteWidget(ctx);
+    setRemoteStatus(ctx, undefined);
+    if (!result.online) {
+      ctx.ui.notify("Pi Web UI is not running; cleared the remote QR widget.", "warning");
+      return;
+    }
+    ctx.ui.notify("Pi Web UI LAN access closed. The local Web UI server may keep running on localhost.", "info");
+  } finally {
+    setRemoteStatus(ctx, undefined);
+  }
+}
+
+async function handleOpen(options: RemoteOptions, ctx: ExtensionCommandContext, controller: RemoteWebuiController): Promise<void> {
+  if (!(await confirmRemoteOpen(options, ctx))) {
+    ctx.ui.notify("Remote WebUI cancelled; LAN access was not opened.", "info");
+    return;
+  }
+
+  setRemoteStatus(ctx, "opening remote webui…");
+  const result = await openRemoteWebui(options, {
+    controller,
+    startWebui: async (startOptions: RemoteOptions) => spawnWebui(startOptions, ctx),
+  });
+  await renderRemoteWidget(ctx, result);
+  ctx.ui.notify(`Pi Remote WebUI ready:\n${result.url}\n\nScan the QR code above from your phone.`, "info");
+}
+
+export default function remoteWebuiExtension(pi: ExtensionAPI) {
+  pi.registerCommand("remote", {
+    description: "Open Pi Web UI to a trusted LAN and show a mobile QR code",
+    handler: async (args, ctx) => {
+      let options: RemoteOptions;
+      try {
+        options = parseRemoteArgs(args) as RemoteOptions;
+      } catch (error) {
+        ctx.ui.notify(`${error instanceof Error ? error.message : String(error)}\n${usage()}`, "error");
+        return;
+      }
+
+      const controller = new RemoteWebuiController();
+      try {
+        if (options.action === "status") {
+          await handleStatus(options, ctx, controller);
+          return;
+        }
+        if (options.action === "refresh") {
+          await handleRefresh(options, ctx, controller);
+          return;
+        }
+        if (options.action === "close") {
+          await handleClose(options, ctx, controller);
+          return;
+        }
+        await handleOpen(options, ctx, controller);
+      } catch (error) {
+        setRemoteStatus(ctx, undefined);
+        ctx.ui.notify(`Pi Remote WebUI failed:\n${error instanceof Error ? error.message : String(error)}\n${usage()}`, "error");
+      }
+    },
+  });
+}

package/lib/remote-core.mjs

@@ -0,0 +1,350 @@
+import { setTimeout as sleep } from "node:timers/promises";
+
+export const DEFAULT_PORT = 31415;
+export const DEFAULT_LOCAL_HOST = "127.0.0.1";
+export const DEFAULT_START_TIMEOUT_MS = 12_000;
+export const DEFAULT_NETWORK_TIMEOUT_MS = 8_000;
+export const DEFAULT_POLL_MS = 250;
+
+export const REMOTE_WIDGET_KEY = "pi-remote-webui";
+
+const ACTIONS = new Set(["open", "status", "close", "refresh"]);
+
+export function tokenizeArgs(input = "") {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+
+  for (const char of String(input || "")) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = undefined;
+      else current += char;
+      continue;
+    }
+    if (char === "\"" || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+
+  if (escaped) current += "\\";
+  if (quote) throw new Error(`Unclosed ${quote} quote`);
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+function takeValue(tokens, index, flag) {
+  const value = tokens[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+export function parsePort(value, label = "port") {
+  const port = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535 || String(port) !== String(value).trim()) {
+    throw new Error(`${label} must be a TCP port between 1 and 65535`);
+  }
+  return port;
+}
+
+export function parseRemoteArgs(args = "") {
+  const options = {
+    action: "open",
+    port: DEFAULT_PORT,
+    name: undefined,
+    yes: false,
+  };
+  const tokens = tokenizeArgs(args);
+  let actionSeen = false;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const lower = token.toLowerCase();
+
+    if (ACTIONS.has(lower) && !actionSeen) {
+      options.action = lower === "open" ? "open" : lower;
+      actionSeen = true;
+      continue;
+    }
+    if (token === "--yes" || token === "-y") {
+      options.yes = true;
+      continue;
+    }
+    if (token === "--port") {
+      options.port = parsePort(takeValue(tokens, i, token), "--port");
+      i++;
+      continue;
+    }
+    if (token.startsWith("--port=")) {
+      options.port = parsePort(token.slice("--port=".length), "--port");
+      continue;
+    }
+    if (token === "--name") {
+      options.name = takeValue(tokens, i, token).trim();
+      if (!options.name) throw new Error("--name requires a non-empty value");
+      i++;
+      continue;
+    }
+    if (token.startsWith("--name=")) {
+      options.name = token.slice("--name=".length).trim();
+      if (!options.name) throw new Error("--name requires a non-empty value");
+      continue;
+    }
+    if (/^\d+$/.test(token)) {
+      options.port = parsePort(token, "port");
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${token}`);
+  }
+
+  return options;
+}
+
+export function usage() {
+  return [
+    "Usage: /remote [status|close|refresh] [port] [--port N] [--name NAME] [--yes]",
+    "Opens the existing Pi Web UI to a trusted local network and shows a QR code for mobile.",
+  ].join("\n");
+}
+
+export function requiresOpenConfirmation(options) {
+  return options?.action === "open" && options?.yes !== true;
+}
+
+export function localBaseUrl(port) {
+  return `http://${DEFAULT_LOCAL_HOST}:${parsePort(port)}`;
+}
+
+export function endpointUrl(port, path) {
+  return `${localBaseUrl(port)}${path.startsWith("/") ? path : `/${path}`}`;
+}
+
+export async function fetchJsonWithTimeout(url, init = {}, timeoutMs = 1_500, fetchImpl = globalThis.fetch) {
+  if (typeof fetchImpl !== "function") throw new Error("fetch is not available in this Node.js runtime");
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(url, { ...init, signal: controller.signal });
+    const body = await response.json().catch(() => undefined);
+    return { ok: response.ok, status: response.status, body };
+  } catch (error) {
+    return { ok: false, status: 0, body: undefined, error };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export class RemoteWebuiController {
+  constructor({ fetchImpl = globalThis.fetch, sleepImpl = sleep } = {}) {
+    this.fetchImpl = fetchImpl;
+    this.sleepImpl = sleepImpl;
+  }
+
+  async probeHealth(port, timeoutMs = 1_200) {
+    const result = await fetchJsonWithTimeout(endpointUrl(port, "/api/health"), {}, timeoutMs, this.fetchImpl);
+    const body = result.body;
+    if (result.ok && body?.ok === true && typeof body.webuiVersion === "string") {
+      return { online: true, status: result.status, data: body };
+    }
+    return {
+      online: false,
+      status: result.status,
+      error: body?.error || result.error?.message || "No Pi Web UI responded at this URL",
+    };
+  }
+
+  async waitForHealth(port, { timeoutMs = DEFAULT_START_TIMEOUT_MS, pollMs = DEFAULT_POLL_MS } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    let last = await this.probeHealth(port, Math.min(1_200, timeoutMs));
+    while (!last.online && Date.now() < deadline) {
+      await this.sleepImpl(pollMs);
+      last = await this.probeHealth(port, Math.min(1_200, Math.max(200, deadline - Date.now())));
+    }
+    if (!last.online) throw new Error(`Timed out waiting for Pi Web UI at ${localBaseUrl(port)}/`);
+    return last;
+  }
+
+  async getNetwork(port, timeoutMs = 1_500) {
+    const result = await fetchJsonWithTimeout(endpointUrl(port, "/api/network"), {}, timeoutMs, this.fetchImpl);
+    if (result.ok && result.body?.ok === true && result.body.data && typeof result.body.data === "object") return result.body.data;
+    throw new Error(result.body?.error || "Failed to read Pi Web UI network status");
+  }
+
+  async openNetwork(port, timeoutMs = 1_500) {
+    const result = await fetchJsonWithTimeout(endpointUrl(port, "/api/network/open"), { method: "POST" }, timeoutMs, this.fetchImpl);
+    if (result.ok && result.body?.ok === true) return result.body.data;
+    throw new Error(result.body?.error || "Failed to open Pi Web UI to the local network");
+  }
+
+  async closeNetwork(port, timeoutMs = 1_500) {
+    const result = await fetchJsonWithTimeout(endpointUrl(port, "/api/network/close"), { method: "POST" }, timeoutMs, this.fetchImpl);
+    if (result.ok && result.body?.ok === true) return result.body.data;
+    throw new Error(result.body?.error || "Failed to close Pi Web UI network access");
+  }
+
+  async waitForNetworkOpen(port, { timeoutMs = DEFAULT_NETWORK_TIMEOUT_MS, pollMs = DEFAULT_POLL_MS } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    let last;
+    do {
+      last = await this.getNetwork(port, Math.min(1_500, Math.max(200, deadline - Date.now())));
+      if (last?.open === true && selectLanUrl(last)) return last;
+      await this.sleepImpl(pollMs);
+    } while (Date.now() < deadline);
+
+    if (last?.open === true) {
+      throw new Error("Pi Web UI is open to the network, but no LAN URL was reported. Check Wi-Fi/LAN connectivity.");
+    }
+    throw new Error("Timed out waiting for Pi Web UI to open to the local network");
+  }
+
+  async status(port) {
+    const health = await this.probeHealth(port);
+    if (!health.online) return { online: false, url: `${localBaseUrl(port)}/`, health };
+    let network;
+    try {
+      network = await this.getNetwork(port);
+    } catch (error) {
+      network = health.data?.network;
+      if (!network) return { online: true, url: `${localBaseUrl(port)}/`, health, error: error?.message || String(error) };
+    }
+    return { online: true, url: selectLanUrl(network) || network?.localUrl || `${localBaseUrl(port)}/`, health, network };
+  }
+}
+
+export function selectLanUrl(network) {
+  const urls = Array.isArray(network?.networkUrls) ? network.networkUrls : [];
+  return urls.find((url) => typeof url === "string" && /^https?:\/\//i.test(url)) || undefined;
+}
+
+export async function openRemoteWebui(options, { controller, startWebui }) {
+  if (!controller) throw new Error("RemoteWebuiController is required");
+  let health = await controller.probeHealth(options.port);
+  let started = false;
+
+  if (!health.online) {
+    if (typeof startWebui !== "function") throw new Error("Pi Web UI is not running and no start function is available");
+    await startWebui(options);
+    started = true;
+    health = await controller.waitForHealth(options.port);
+  }
+
+  let network;
+  try {
+    network = await controller.getNetwork(options.port);
+  } catch {
+    network = health.data?.network;
+  }
+
+  if (!network?.open || network?.closing) {
+    await controller.openNetwork(options.port);
+    network = await controller.waitForNetworkOpen(options.port);
+  } else if (!selectLanUrl(network)) {
+    network = await controller.waitForNetworkOpen(options.port, { timeoutMs: 2_000 });
+  }
+
+  const url = selectLanUrl(network);
+  if (!url) throw new Error("No LAN URL was reported by Pi Web UI. Connect this machine to a local network and retry.");
+  return { started, health, network, url };
+}
+
+export async function closeRemoteWebui(options, { controller }) {
+  if (!controller) throw new Error("RemoteWebuiController is required");
+  const health = await controller.probeHealth(options.port);
+  if (!health.online) return { online: false, url: `${localBaseUrl(options.port)}/`, health };
+  const network = await controller.closeNetwork(options.port);
+  return { online: true, url: `${localBaseUrl(options.port)}/`, health, network };
+}
+
+export function formatStatus(status) {
+  if (!status?.online) {
+    return [
+      "Pi Remote WebUI status",
+      "",
+      `URL:     ${status?.url || "unknown"}`,
+      "Online:  no",
+      `Error:   ${status?.health?.error || "offline"}`,
+      "",
+      "Start and show QR with: /remote",
+    ].join("\n");
+  }
+
+  const network = status.network || status.health?.data?.network || {};
+  const networkUrls = Array.isArray(network.networkUrls) ? network.networkUrls : [];
+  const state = network.open ? (network.opening ? "opening to LAN" : "open to LAN") : network.closing ? "closing" : "local only";
+  const lines = [
+    "Pi Remote WebUI status",
+    "",
+    `URL:      ${status.url || selectLanUrl(network) || network.localUrl || "unknown"}`,
+    "Online:   yes",
+    `Network:  ${state}`,
+    `Bind:     ${network.host || "unknown"}:${network.port || "?"}`,
+  ];
+  if (networkUrls.length) lines.push(`LAN URLs: ${networkUrls.join(", ")}`);
+  if (status.health?.data?.webuiVersion) lines.push(`Version:  ${status.health.data.webuiVersion}`);
+  if (status.error) lines.push(`Warning:  ${status.error}`);
+  return lines.join("\n");
+}
+
+export function buildRemoteWidgetLines({ url, qrLines = [], network = {}, started = false } = {}) {
+  const auth = network?.auth || {};
+  const authLine = auth.enabled ? `Remote PIN auth: on${auth.pin ? ` · PIN ${auth.pin}` : ""}` : "Remote PIN auth: off";
+  const warningLine = auth.enabled
+    ? "Trusted LAN only. Anyone with this URL and PIN can control Pi/WebUI."
+    : "Trusted LAN only. Remote PIN auth is off; anyone with this URL can control Pi/WebUI.";
+  const lines = [
+    "Pi Remote WebUI",
+    "",
+    "Scan with your phone:",
+    "",
+    ...qrLines,
+    "",
+    url || selectLanUrl(network) || network.localUrl || "(no URL)",
+    authLine,
+    "",
+    warningLine,
+    "Close LAN access with: /remote close",
+  ];
+  if (started) lines.push("Started a Pi Web UI server for this session.");
+  return lines;
+}
+
+export async function generateQrLines(url, { qrcodeModule } = {}) {
+  let qrcode = qrcodeModule;
+  if (!qrcode) {
+    try {
+      qrcode = (await import("qrcode-terminal")).default || (await import("qrcode-terminal"));
+    } catch {
+      return ["[QR generator unavailable: qrcode-terminal is not installed]"];
+    }
+  }
+
+  return new Promise((resolve) => {
+    try {
+      qrcode.generate(url, { small: true }, (qrText) => {
+        const lines = String(qrText || "").split(/\r?\n/);
+        resolve(lines.filter((line, index, array) => line.trim() || (index > 0 && index < array.length - 1)));
+      });
+    } catch (error) {
+      resolve([`[QR generation failed: ${error?.message || String(error)}]`]);
+    }
+  });
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@firstpick/pi-package-remote-webui",
+  "version": "0.1.0",
+  "description": "Pi /remote command that opens the existing Pi Web UI to a trusted LAN and shows a QR code for mobile.",
+  "license": "MIT",
+  "homepage": "https://github.com/Firstp1ck/npm-packages/tree/main/pi-package-remote-webui#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Firstp1ck/npm-packages.git",
+    "directory": "pi-package-remote-webui"
+  },
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "webui",
+    "remote",
+    "mobile",
+    "qr",
+    "extension"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "check": "node --check lib/remote-core.mjs && node tests/run-all.mjs",
+    "test": "node tests/run-all.mjs"
+  },
+  "dependencies": {
+    "@firstpick/pi-package-webui": "^0.3.8",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "files": [
+    "index.ts",
+    "lib",
+    "tests",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}