very-happy-cli 0.2.178 → 0.2.180

package/dist/{mirrorProtocol-6IFGPpjJ.mjs → mirrorProtocol-BR4luBC0.mjs}

@@ -1,11 +1,11 @@
+import { randomBytes, createHash, randomUUID } from 'node:crypto';
+import { promises, constants, writeFileSync, chmodSync, openSync, fstatSync, closeSync, existsSync, readFileSync, renameSync, readdirSync, rmSync, lstatSync, realpathSync, statSync, mkdirSync, readSync, unlinkSync, rmdirSync } from 'node:fs';
+import { join, dirname, basename, relative, isAbsolute, sep, resolve } from 'node:path';
 import { spawn, execFileSync, execFile } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { constants, writeFileSync, chmodSync, openSync, fstatSync, closeSync, existsSync, readFileSync, renameSync, readdirSync, rmSync, lstatSync, realpathSync, statSync, mkdirSync, readSync, unlinkSync, rmdirSync } from 'node:fs';
-import { relative, isAbsolute, sep, join, dirname, basename, resolve } from 'node:path';
 import { realpath, lstat, stat, mkdir, copyFile, symlink, readdir } from 'node:fs/promises';
-import { f as ensurePrivateDirectorySync, w as writePrivateFileSync } from './configuration-DVrb61aY.mjs';
-import { p as AGENT_VERSION_SOURCES } from './index-Clqlu17M.mjs';
-import { p as packageJson } from './package-B7B03ejW.mjs';
+import { f as ensurePrivateDirectorySync, w as writePrivateFileSync } from './configuration-PxzEJumr.mjs';
+import { r as AGENT_VERSION_SOURCES } from './index-C6Vn5Eac.mjs';
+import { p as packageJson } from './package-7Ld1YMhh.mjs';
 
 function summarizeSpawnSessionForLog(value) {
   const input = value && typeof value === "object" ? value : {};
@@ -41,6 +41,147 @@ function registerWorktreeHandlers(rpc, service) {
   rpc.registerHandler("worktree-remove", async (params) => service.remove(obj(params).path, obj(params).discardChanges, obj(params).expectedFingerprint));
 }
 
+const MAX_CONFIG_BYTES = 1024 * 1024;
+const MAX_BACKUPS_PER_HARNESS = 20;
+class ModelConfigError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ModelConfigError";
+  }
+}
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+async function readConfigFile(path) {
+  let stat;
+  try {
+    stat = await promises.stat(path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path, exists: false, content: "", hash: sha256(""), mode: null };
+    }
+    throw new ModelConfigError("read-failed", `Cannot read ${path}: ${error.message}`);
+  }
+  if (!stat.isFile()) throw new ModelConfigError("not-a-file", `${path} is not a regular file`);
+  if (stat.size > MAX_CONFIG_BYTES) throw new ModelConfigError("file-too-large", `${path} is larger than ${MAX_CONFIG_BYTES} bytes`);
+  const content = await promises.readFile(path, "utf8");
+  return { path, exists: true, content, hash: sha256(content), mode: stat.mode & 511 };
+}
+async function resolveWriteTarget(path) {
+  try {
+    return await promises.realpath(path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      try {
+        const link = await promises.readlink(path);
+        return link.startsWith("/") ? link : join(dirname(path), link);
+      } catch {
+        return path;
+      }
+    }
+    throw error;
+  }
+}
+async function atomicWriteFile(path, content, mode) {
+  const target = await resolveWriteTarget(path);
+  const dir = dirname(target);
+  await promises.mkdir(dir, { recursive: true, mode: 448 });
+  const tmp = join(dir, `.${basename(target)}.vh-tmp-${process.pid}-${randomBytes(4).toString("hex")}`);
+  const handle = await promises.open(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, mode ?? 384);
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    await promises.unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+  await handle.close();
+  try {
+    if (mode !== null) await promises.chmod(tmp, mode);
+    await promises.rename(tmp, target);
+  } catch (error) {
+    await promises.unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+  try {
+    const dirHandle = await promises.open(dir, "r");
+    await dirHandle.sync().catch(() => {
+    });
+    await dirHandle.close();
+  } catch {
+  }
+}
+const BACKUP_ID = /^\d{13}-[0-9a-f]{8}$/;
+const HARNESS_DIR = /^[a-z][a-z0-9-]{0,31}$/;
+class BackupStore {
+  constructor(root) {
+    this.root = root;
+  }
+  harnessDir(harness) {
+    if (!HARNESS_DIR.test(harness)) throw new ModelConfigError("invalid-harness", "Invalid harness");
+    return join(this.root, harness);
+  }
+  async create(harness, reason, files, now = Date.now()) {
+    const id = `${now}-${randomBytes(4).toString("hex")}`;
+    const dir = join(this.harnessDir(harness), id);
+    await promises.mkdir(dir, { recursive: true, mode: 448 });
+    const manifest = { id, createdAt: now, reason, files: files.map((f, i) => ({ path: f.path, blob: f.content === null ? null : `f${i}`, mode: f.mode })) };
+    for (const [i, file] of files.entries()) {
+      if (file.content !== null) await promises.writeFile(join(dir, `f${i}`), file.content, { encoding: "utf8", mode: 384 });
+    }
+    await promises.writeFile(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2), { encoding: "utf8", mode: 384 });
+    await this.prune(harness);
+    return { id, createdAt: now, reason, files: files.map((f) => f.path) };
+  }
+  async list(harness) {
+    let names;
+    try {
+      names = await promises.readdir(this.harnessDir(harness));
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const name of names.filter((n) => BACKUP_ID.test(n))) {
+      try {
+        const manifest = JSON.parse(await promises.readFile(join(this.harnessDir(harness), name, "manifest.json"), "utf8"));
+        entries.push({ id: name, createdAt: Number(manifest.createdAt) || 0, reason: String(manifest.reason ?? ""), files: (manifest.files ?? []).map((f) => f.path) });
+      } catch {
+      }
+    }
+    return entries.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async read(harness, id) {
+    if (!BACKUP_ID.test(id)) throw new ModelConfigError("invalid-backup", "Invalid backup id");
+    const dir = join(this.harnessDir(harness), id);
+    let manifest;
+    try {
+      manifest = JSON.parse(await promises.readFile(join(dir, "manifest.json"), "utf8"));
+    } catch {
+      throw new ModelConfigError("backup-not-found", "Backup not found");
+    }
+    const out = [];
+    for (const file of manifest.files) {
+      out.push({
+        path: file.path,
+        content: file.blob === null ? null : await promises.readFile(join(dir, file.blob), "utf8"),
+        mode: typeof file.mode === "number" ? file.mode : null
+      });
+    }
+    return out;
+  }
+  async prune(harness) {
+    const entries = await this.list(harness);
+    for (const stale of entries.slice(MAX_BACKUPS_PER_HARNESS)) {
+      await promises.rm(join(this.harnessDir(harness), stale.id), { recursive: true, force: true });
+    }
+  }
+}
+
 const CONFIG_RELATIVE_PATH = ".veryhappy/worktree.json";
 const CONFIG_MAX_BYTES = 64 * 1024;
 const SCRIPT_MAX_BYTES = 32 * 1024;
@@ -1244,4 +1385,4 @@ function decideBackfill(messages, maxLines) {
   return { replay: messages.slice(messages.length - cap), truncated: true };
 }
 
-export { MIRROR_BACKFILL_LINES_DEFAULT as M, WORKTREE_CAPABILITY_VERSION as W, sanitizeTagList as a, sanitizeLiveSnapshot as b, serializeLiveSnapshot as c, configureWorktreeService as d, summarizeSpawnSessionForLog as e, parseMirrorSendParams as f, extractCompleteLines as g, decideBackfill as h, isClaudeSessionId as i, parseTerminalHookPayload as j, decideMirrorBinding as k, liveSnapshotChanged as l, mirrorLineKey as m, mirrorLocalId as n, initializeOwnedWorktree as o, pickMirrorForTerminal as p, startAgentVersionChecks as q, registerWorktreeHandlers as r, stableVersion as s, currentWorktreeService as t };
+export { BackupStore as B, ModelConfigError as M, WORKTREE_CAPABILITY_VERSION as W, sanitizeTagList as a, sanitizeLiveSnapshot as b, serializeLiveSnapshot as c, configureWorktreeService as d, summarizeSpawnSessionForLog as e, parseMirrorSendParams as f, readConfigFile as g, sha256 as h, isClaudeSessionId as i, atomicWriteFile as j, extractCompleteLines as k, liveSnapshotChanged as l, decideBackfill as m, parseTerminalHookPayload as n, decideMirrorBinding as o, pickMirrorForTerminal as p, MIRROR_BACKFILL_LINES_DEFAULT as q, registerWorktreeHandlers as r, stableVersion as s, mirrorLineKey as t, mirrorLocalId as u, initializeOwnedWorktree as v, startAgentVersionChecks as w, currentWorktreeService as x };

package/dist/{mirrorProtocol-qKflWTX_.cjs → mirrorProtocol-HKPivs5o.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 
-var node_child_process = require('node:child_process');
 var node_crypto = require('node:crypto');
 var node_fs = require('node:fs');
 var path = require('node:path');
+var node_child_process = require('node:child_process');
 var promises = require('node:fs/promises');
-var configuration = require('./configuration-4TGMrjul.cjs');
-var index = require('./index-_l1Sdmbi.cjs');
-var _package = require('./package-DY4zTbKS.cjs');
+var configuration = require('./configuration-CYO-kPOS.cjs');
+var index = require('./index-Dv0Q48P3.cjs');
+var _package = require('./package-KhLqBDX9.cjs');
 
 function summarizeSpawnSessionForLog(value) {
   const input = value && typeof value === "object" ? value : {};
@@ -43,6 +43,147 @@ function registerWorktreeHandlers(rpc, service) {
   rpc.registerHandler("worktree-remove", async (params) => service.remove(obj(params).path, obj(params).discardChanges, obj(params).expectedFingerprint));
 }
 
+const MAX_CONFIG_BYTES = 1024 * 1024;
+const MAX_BACKUPS_PER_HARNESS = 20;
+class ModelConfigError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ModelConfigError";
+  }
+}
+function sha256(text) {
+  return node_crypto.createHash("sha256").update(text).digest("hex");
+}
+async function readConfigFile(path) {
+  let stat;
+  try {
+    stat = await node_fs.promises.stat(path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path, exists: false, content: "", hash: sha256(""), mode: null };
+    }
+    throw new ModelConfigError("read-failed", `Cannot read ${path}: ${error.message}`);
+  }
+  if (!stat.isFile()) throw new ModelConfigError("not-a-file", `${path} is not a regular file`);
+  if (stat.size > MAX_CONFIG_BYTES) throw new ModelConfigError("file-too-large", `${path} is larger than ${MAX_CONFIG_BYTES} bytes`);
+  const content = await node_fs.promises.readFile(path, "utf8");
+  return { path, exists: true, content, hash: sha256(content), mode: stat.mode & 511 };
+}
+async function resolveWriteTarget(path$1) {
+  try {
+    return await node_fs.promises.realpath(path$1);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      try {
+        const link = await node_fs.promises.readlink(path$1);
+        return link.startsWith("/") ? link : path.join(path.dirname(path$1), link);
+      } catch {
+        return path$1;
+      }
+    }
+    throw error;
+  }
+}
+async function atomicWriteFile(path$1, content, mode) {
+  const target = await resolveWriteTarget(path$1);
+  const dir = path.dirname(target);
+  await node_fs.promises.mkdir(dir, { recursive: true, mode: 448 });
+  const tmp = path.join(dir, `.${path.basename(target)}.vh-tmp-${process.pid}-${node_crypto.randomBytes(4).toString("hex")}`);
+  const handle = await node_fs.promises.open(tmp, node_fs.constants.O_WRONLY | node_fs.constants.O_CREAT | node_fs.constants.O_EXCL, mode ?? 384);
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    await node_fs.promises.unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+  await handle.close();
+  try {
+    if (mode !== null) await node_fs.promises.chmod(tmp, mode);
+    await node_fs.promises.rename(tmp, target);
+  } catch (error) {
+    await node_fs.promises.unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+  try {
+    const dirHandle = await node_fs.promises.open(dir, "r");
+    await dirHandle.sync().catch(() => {
+    });
+    await dirHandle.close();
+  } catch {
+  }
+}
+const BACKUP_ID = /^\d{13}-[0-9a-f]{8}$/;
+const HARNESS_DIR = /^[a-z][a-z0-9-]{0,31}$/;
+class BackupStore {
+  constructor(root) {
+    this.root = root;
+  }
+  harnessDir(harness) {
+    if (!HARNESS_DIR.test(harness)) throw new ModelConfigError("invalid-harness", "Invalid harness");
+    return path.join(this.root, harness);
+  }
+  async create(harness, reason, files, now = Date.now()) {
+    const id = `${now}-${node_crypto.randomBytes(4).toString("hex")}`;
+    const dir = path.join(this.harnessDir(harness), id);
+    await node_fs.promises.mkdir(dir, { recursive: true, mode: 448 });
+    const manifest = { id, createdAt: now, reason, files: files.map((f, i) => ({ path: f.path, blob: f.content === null ? null : `f${i}`, mode: f.mode })) };
+    for (const [i, file] of files.entries()) {
+      if (file.content !== null) await node_fs.promises.writeFile(path.join(dir, `f${i}`), file.content, { encoding: "utf8", mode: 384 });
+    }
+    await node_fs.promises.writeFile(path.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2), { encoding: "utf8", mode: 384 });
+    await this.prune(harness);
+    return { id, createdAt: now, reason, files: files.map((f) => f.path) };
+  }
+  async list(harness) {
+    let names;
+    try {
+      names = await node_fs.promises.readdir(this.harnessDir(harness));
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const name of names.filter((n) => BACKUP_ID.test(n))) {
+      try {
+        const manifest = JSON.parse(await node_fs.promises.readFile(path.join(this.harnessDir(harness), name, "manifest.json"), "utf8"));
+        entries.push({ id: name, createdAt: Number(manifest.createdAt) || 0, reason: String(manifest.reason ?? ""), files: (manifest.files ?? []).map((f) => f.path) });
+      } catch {
+      }
+    }
+    return entries.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async read(harness, id) {
+    if (!BACKUP_ID.test(id)) throw new ModelConfigError("invalid-backup", "Invalid backup id");
+    const dir = path.join(this.harnessDir(harness), id);
+    let manifest;
+    try {
+      manifest = JSON.parse(await node_fs.promises.readFile(path.join(dir, "manifest.json"), "utf8"));
+    } catch {
+      throw new ModelConfigError("backup-not-found", "Backup not found");
+    }
+    const out = [];
+    for (const file of manifest.files) {
+      out.push({
+        path: file.path,
+        content: file.blob === null ? null : await node_fs.promises.readFile(path.join(dir, file.blob), "utf8"),
+        mode: typeof file.mode === "number" ? file.mode : null
+      });
+    }
+    return out;
+  }
+  async prune(harness) {
+    const entries = await this.list(harness);
+    for (const stale of entries.slice(MAX_BACKUPS_PER_HARNESS)) {
+      await node_fs.promises.rm(path.join(this.harnessDir(harness), stale.id), { recursive: true, force: true });
+    }
+  }
+}
+
 const CONFIG_RELATIVE_PATH = ".veryhappy/worktree.json";
 const CONFIG_MAX_BYTES = 64 * 1024;
 const SCRIPT_MAX_BYTES = 32 * 1024;
@@ -1246,8 +1387,11 @@ function decideBackfill(messages, maxLines) {
   return { replay: messages.slice(messages.length - cap), truncated: true };
 }
 
+exports.BackupStore = BackupStore;
 exports.MIRROR_BACKFILL_LINES_DEFAULT = MIRROR_BACKFILL_LINES_DEFAULT;
+exports.ModelConfigError = ModelConfigError;
 exports.WORKTREE_CAPABILITY_VERSION = WORKTREE_CAPABILITY_VERSION;
+exports.atomicWriteFile = atomicWriteFile;
 exports.configureWorktreeService = configureWorktreeService;
 exports.currentWorktreeService = currentWorktreeService;
 exports.decideBackfill = decideBackfill;
@@ -1261,10 +1405,12 @@ exports.mirrorLocalId = mirrorLocalId;
 exports.parseMirrorSendParams = parseMirrorSendParams;
 exports.parseTerminalHookPayload = parseTerminalHookPayload;
 exports.pickMirrorForTerminal = pickMirrorForTerminal;
+exports.readConfigFile = readConfigFile;
 exports.registerWorktreeHandlers = registerWorktreeHandlers;
 exports.sanitizeLiveSnapshot = sanitizeLiveSnapshot;
 exports.sanitizeTagList = sanitizeTagList;
 exports.serializeLiveSnapshot = serializeLiveSnapshot;
+exports.sha256 = sha256;
 exports.stableVersion = stableVersion;
 exports.startAgentVersionChecks = startAgentVersionChecks;
 exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;

package/dist/{package-B7B03ejW.mjs → package-7Ld1YMhh.mjs}

@@ -1,5 +1,5 @@
 var name = "very-happy-cli";
-var version = "0.2.178";
+var version = "0.2.180";
 var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
 var author = "Kirill Dubovitskiy";
 var contributors = [
@@ -116,12 +116,12 @@ var dependencies = {
 	zod: "^4.0.0"
 };
 var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.178",
-	"very-happy-tools-x64-darwin": "0.2.178",
-	"very-happy-tools-arm64-linux": "0.2.178",
-	"very-happy-tools-x64-linux": "0.2.178",
-	"very-happy-tools-arm64-win32": "0.2.178",
-	"very-happy-tools-x64-win32": "0.2.178"
+	"very-happy-tools-arm64-darwin": "0.2.180",
+	"very-happy-tools-x64-darwin": "0.2.180",
+	"very-happy-tools-arm64-linux": "0.2.180",
+	"very-happy-tools-x64-linux": "0.2.180",
+	"very-happy-tools-arm64-win32": "0.2.180",
+	"very-happy-tools-x64-win32": "0.2.180"
 };
 var devDependencies = {
 	"@slopus/happy-wire": "workspace:*",
@@ -133,6 +133,7 @@ var devDependencies = {
 	"cross-env": "^10.1.0",
 	dotenv: "^16.6.1",
 	pkgroll: "^2.14.2",
+	"smol-toml": "1.9.0",
 	"ts-node": "^10",
 	tsx: "^4.20.6",
 	typescript: "5.9.3",

package/dist/{package-DY4zTbKS.cjs → package-KhLqBDX9.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var name = "very-happy-cli";
-var version = "0.2.178";
+var version = "0.2.180";
 var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
 var author = "Kirill Dubovitskiy";
 var contributors = [
@@ -118,12 +118,12 @@ var dependencies = {
 	zod: "^4.0.0"
 };
 var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.178",
-	"very-happy-tools-x64-darwin": "0.2.178",
-	"very-happy-tools-arm64-linux": "0.2.178",
-	"very-happy-tools-x64-linux": "0.2.178",
-	"very-happy-tools-arm64-win32": "0.2.178",
-	"very-happy-tools-x64-win32": "0.2.178"
+	"very-happy-tools-arm64-darwin": "0.2.180",
+	"very-happy-tools-x64-darwin": "0.2.180",
+	"very-happy-tools-arm64-linux": "0.2.180",
+	"very-happy-tools-x64-linux": "0.2.180",
+	"very-happy-tools-arm64-win32": "0.2.180",
+	"very-happy-tools-x64-win32": "0.2.180"
 };
 var devDependencies = {
 	"@slopus/happy-wire": "workspace:*",
@@ -135,6 +135,7 @@ var devDependencies = {
 	"cross-env": "^10.1.0",
 	dotenv: "^16.6.1",
 	pkgroll: "^2.14.2",
+	"smol-toml": "1.9.0",
 	"ts-node": "^10",
 	tsx: "^4.20.6",
 	typescript: "5.9.3",

package/dist/panels-C7IVqpJk.mjs

@@ -0,0 +1,137 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { c as configuration } from './configuration-PxzEJumr.mjs';
+import { b as readCredentialsForConfiguredRelay, r as readSettings } from './persistence-BFUOHW5h.mjs';
+import { n as normalizeWebPanels, w as webPanelPath } from './webPanels-B2_C2-3g.mjs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import './package-7Ld1YMhh.mjs';
+import 'node:fs/promises';
+import 'zod';
+import './authRelay-DhQhkBvX.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import './logger-BUngm5Xg.mjs';
+import 'node:util';
+
+function frameVerdict(headers) {
+  const xfo = headers["x-frame-options"]?.trim().toUpperCase();
+  if (xfo === "DENY" || xfo === "SAMEORIGIN") return { embeddable: false, reason: `X-Frame-Options: ${xfo}` };
+  const csp = headers["content-security-policy"] ?? "";
+  const fa = csp.split(";").map((d) => d.trim()).find((d) => d.toLowerCase().startsWith("frame-ancestors"));
+  if (fa) {
+    const sources = fa.split(/\s+/).slice(1);
+    if (!sources.includes("*") && !sources.some((s) => /veryhappy\.dev/.test(s))) {
+      return { embeddable: false, reason: `CSP ${fa}` };
+    }
+  }
+  return { embeddable: true };
+}
+function printPanels(panels, problems) {
+  if (panels.length === 0 && problems.length === 0) {
+    console.log("No webPanels declared in", configuration.settingsFile);
+    console.log(chalk.gray('Add e.g. "webPanels": [{ "id": "desktop", "title": "Desktop", "url": "https://host.example.ts.net:6443/vnc.html" }]'));
+    return;
+  }
+  for (const p of panels) console.log(`${chalk.bold(p.id.padEnd(16))} ${p.title.padEnd(20)} ${p.url}${p.embed ? "" : chalk.gray("  (open in new window)")}`);
+  for (const p of problems) console.log(chalk.yellow(`skipped #${p.index}${p.id ? ` (${p.id})` : ""}: ${p.reason}`));
+}
+async function handlePanelsCommand(args) {
+  const action = args[0] ?? "list";
+  const { panels, problems } = normalizeWebPanels((await readSettings()).webPanels);
+  if (action === "list") {
+    printPanels(panels, problems);
+    return;
+  }
+  if (action !== "check") {
+    console.log(`${chalk.bold("very-happy panels")} \u2014 web panels declared in ${configuration.settingsFile}
+
+  very-happy panels list     Show the declared panels (and skipped entries)
+  very-happy panels check    Fetch each URL from THIS machine: reachable? embeddable?`);
+    return;
+  }
+  printPanels(panels, problems);
+  for (const p of panels) {
+    try {
+      const res = await axios.get(p.url, { timeout: 8e3, maxRedirects: 3, validateStatus: () => true, responseType: "stream" });
+      res.data.destroy?.();
+      const headers = Object.fromEntries(Object.entries(res.headers).map(([k, v]) => [k.toLowerCase(), Array.isArray(v) ? v.join(", ") : v == null ? void 0 : String(v)]));
+      const frame = frameVerdict(headers);
+      const notes = [
+        `HTTP ${res.status}`,
+        p.url.startsWith("https:") ? "https" : chalk.yellow("http (only usable from this machine)"),
+        frame.embeddable ? "embeddable" : chalk.yellow(`not embeddable (${frame.reason}) \u2192 set "embed": false`)
+      ];
+      console.log(`${p.id}: ${notes.join(" \xB7 ")}`);
+    } catch (error) {
+      console.log(chalk.red(`${p.id}: unreachable from this machine (${error instanceof Error ? error.message : String(error)})`));
+    }
+  }
+  console.log(chalk.gray("Reachable here \u2260 reachable from your phone: the viewer's browser connects to the URL directly (tailnet / tunnel + HTTPS)."));
+}
+function parseAttentionArgs(args) {
+  let panel;
+  let session;
+  const words = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--panel") panel = args[++i];
+    else if (args[i] === "--session") session = args[++i];
+    else if (args[i].startsWith("--")) return { error: `unknown option ${args[i]}` };
+    else words.push(args[i]);
+  }
+  const reason = words.join(" ").replace(/\s+/g, " ").trim().slice(0, 200);
+  if (!reason) return { error: 'usage: very-happy attention "<reason>" [--panel <id>] [--session <sessionId>]' };
+  if (args.includes("--panel") && !panel || args.includes("--session") && !session) return { error: "missing value after --panel / --session" };
+  return { reason, ...panel ? { panel } : {}, ...session ? { session } : {} };
+}
+async function handleAttentionCommand(args) {
+  const parsed = parseAttentionArgs(args);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    process.exitCode = 1;
+    return;
+  }
+  const credentials = await readCredentialsForConfiguredRelay();
+  const settings = await readSettings();
+  if (!credentials || !settings.machineId) {
+    console.error('Not authenticated on this machine. Run "very-happy auth login" first.');
+    process.exitCode = 1;
+    return;
+  }
+  let link;
+  if (parsed.panel) {
+    const { panels } = normalizeWebPanels(settings.webPanels);
+    if (panels.some((p) => p.id === parsed.panel)) link = webPanelPath(settings.machineId, parsed.panel);
+    else console.error(chalk.yellow(`panel "${parsed.panel}" is not declared in ${configuration.settingsFile}; the notification will not deep-link`));
+  }
+  if (parsed.session) {
+    const { ApiClient } = await import('./api-Hov8p7CA.mjs').then(function (n) { return n.b; });
+    const api = await ApiClient.create(credentials);
+    const r = await api.push().sendAttention({ sessionId: parsed.session, reason: parsed.reason, url: link ?? `/session/${encodeURIComponent(parsed.session)}` });
+    if (!r.sent) {
+      console.error(`Failed: ${r.error}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(r.kind === "attention" ? "Sent." : 'Sent (this server predates "attention"; delivered as a question).');
+    return;
+  }
+  try {
+    const res = await axios.post(`${configuration.serverUrl}/v1/webhook/notify`, {
+      title: "Needs you",
+      message: parsed.reason,
+      event: "permission",
+      ...link ? { link } : {}
+    }, {
+      headers: { Authorization: `Bearer ${credentials.token}`, "Content-Type": "application/json", "X-Happy-Client": `cli/${configuration.currentCliVersion}` },
+      timeout: 15e3
+    });
+    console.log(res.data?.delivered ? "Sent (devices + webhook)." : "Sent to devices (no webhook delivery).");
+  } catch (error) {
+    console.error(`Failed: ${error?.response ? `HTTP ${error.response.status}` : error?.message ?? error}`);
+    process.exitCode = 1;
+  }
+}
+
+export { frameVerdict, handleAttentionCommand, handlePanelsCommand, parseAttentionArgs };