@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-VMC4WSH5.js

@@ -0,0 +1,278 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  buildNpmCommand
+} from "./chunk-6BEFEWFB.js";
+
+// src/utils/optionalPackages.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { basename, dirname, join, sep } from "path";
+var OPTIONAL_PACKAGES = {
+  "onnxruntime-node": "1.21.1",
+  "@google/genai": "1.52.0"
+};
+var PINNED_PACKAGES = {
+  ...OPTIONAL_PACKAGES,
+  "sherpa-onnx-node": "1.13.8"
+};
+var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "optional");
+var SHARP_VERSION = "0.35.3";
+function optionalPackageDir(name, cacheDir = CACHE_DIR) {
+  return join(cacheDir, `${name.replace("/", "__")}@${versionOf(name)}`);
+}
+function versionOf(name) {
+  return name === "sharp" ? SHARP_VERSION : OPTIONAL_PACKAGES[name];
+}
+function installedOptionalPackageVersion(name, cacheDir = CACHE_DIR, cliUrl = import.meta.url) {
+  if (pinnedPackageBesideCli(name, cliUrl)?.resolution === "entry") return OPTIONAL_PACKAGES[name];
+  const dir = optionalPackageDir(name, cacheDir);
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath(dir, name), "utf-8"));
+    if (typeof manifest !== "object" || manifest === null || !("version" in manifest)) return null;
+    const version = manifest.version;
+    return typeof version === "string" && version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+function loadInstalledOptionalPackage(name, deps = defaultDeps) {
+  return loadPresent(name, deps);
+}
+function loadPresent(name, deps) {
+  return deps.loadBesideCli(name) ?? deps.loadInstalled(optionalPackageDir(name, deps.cacheDir), name);
+}
+async function loadOptionalPackage(name, feature, deps = defaultDeps) {
+  return await loadOrInstall(name, feature, deps);
+}
+async function loadSharp(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  return besideCli(feature) ?? sharpExport(await loadOrInstall("sharp", feature, deps));
+}
+var backgroundSharpInstall;
+async function loadSharpInBackground(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  const present = loadInstalledSharp(feature, deps, besideCli);
+  if (present !== null) return present;
+  const install2 = loadOrInstall("sharp", feature, deps);
+  if (backgroundSharpInstall !== install2) {
+    backgroundSharpInstall = install2;
+    install2.catch((err) => deps.log(err.message));
+  }
+  const notYet = /* @__PURE__ */ Symbol("installing");
+  const settled = await Promise.race([install2, notYet]);
+  if (settled === notYet)
+    throw new Error(`sharp is not installed yet; installing it once for ${feature}`);
+  return sharpExport(settled);
+}
+function loadInstalledSharp(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  const found = besideCli(feature) ?? loadPresent("sharp", deps);
+  return found === null ? null : sharpExport(found);
+}
+function requireSharpBesideCli(feature, cliUrl = import.meta.url) {
+  const req = createRequire(cliUrl);
+  let entry;
+  try {
+    entry = req.resolve("sharp");
+  } catch {
+    return null;
+  }
+  try {
+    return sharpExport(req(entry));
+  } catch (err) {
+    throw new Error(
+      `${feature} needs sharp, which is installed but could not load (${err.message}). Reinstall Framey with optional dependencies enabled, or run: npm i sharp`
+    );
+  }
+}
+function sharpExport(module) {
+  const m = module;
+  return m.default ?? m;
+}
+function installTurnedOff(name) {
+  const value = process.env["HYPERFRAMES_NO_OPTIONAL_INSTALL"]?.trim() ?? "";
+  return value === "1" || value.split(",").some((entry) => entry.trim() === name);
+}
+var installs = /* @__PURE__ */ new WeakMap();
+function loadOrInstall(name, feature, deps) {
+  const present = loadPresent(name, deps);
+  if (present !== null) return Promise.resolve(present);
+  let pending = installs.get(deps);
+  if (!pending) installs.set(deps, pending = /* @__PURE__ */ new Map());
+  let install2 = pending.get(name);
+  if (!install2) pending.set(name, install2 = installAndLoad(name, feature, deps));
+  return install2;
+}
+async function installAndLoad(name, feature, deps) {
+  const dir = optionalPackageDir(name, deps.cacheDir);
+  const version = versionOf(name);
+  if (installTurnedOff(name)) {
+    throw new Error(
+      `${name} is not installed, and HYPERFRAMES_NO_OPTIONAL_INSTALL turns off installing it; ${feature} needs it.`
+    );
+  }
+  deps.log(`installing ${name} for ${feature}, once`);
+  try {
+    await deps.install(dir, name, version);
+  } catch (err) {
+    const output = err.message.trim();
+    const advice = NETWORK_FAILURE.test(output) ? "Check your network connection, then retry" : "Retry";
+    throw new Error(
+      `${feature} needs ${name}, and installing it failed (${output.split("\n")[0]}). ${advice}, or install it yourself: npm install ${name}@${version} --prefix "${dir}"`
+    );
+  }
+  const loaded = deps.loadInstalled(dir, name);
+  if (loaded === null) {
+    throw new Error(`${name}@${version} installed into ${dir} but could not be loaded.`);
+  }
+  return loaded;
+}
+var NETWORK_FAILURE = /ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ECONNRESET|ECONNREFUSED|network/i;
+function manifestPath(dir, name) {
+  return join(dir, "node_modules", name, "package.json");
+}
+function isInstalled(dir, name) {
+  return existsSync(manifestPath(dir, name));
+}
+function installedPackagePath(dir, name) {
+  if (!isInstalled(dir, name)) return null;
+  return createRequire(join(dir, "package.json")).resolve(name);
+}
+function loadInstalled(dir, name) {
+  const entry = installedPackagePath(dir, name);
+  return entry === null ? null : createRequire(join(dir, "package.json"))(entry);
+}
+function pinnedPackageBesideCli(name, cliUrl = import.meta.url) {
+  const req = createRequire(cliUrl);
+  try {
+    let entry;
+    try {
+      entry = realpathSync(req.resolve(name));
+    } catch {
+      const copy2 = (req.resolve.paths(name) ?? []).map((dir) => join(dir, name)).find((dir) => existsSync(join(dir, "package.json")));
+      return copy2 && hasPinnedVersion(copy2, name) ? { resolution: "package", path: realpathSync(copy2) } : null;
+    }
+    const copy = (req.resolve.paths(name) ?? []).map((dir) => join(dir, name)).find((dir) => existsSync(dir) && entry.startsWith(realpathSync(dir) + sep));
+    if (!copy) return null;
+    return hasPinnedVersion(copy, name) ? { resolution: "entry", path: entry } : null;
+  } catch {
+    return null;
+  }
+}
+function hasPinnedVersion(copy, name) {
+  const manifest = readFileSync(join(copy, "package.json"), "utf-8");
+  return JSON.parse(manifest).version === PINNED_PACKAGES[name];
+}
+function loadBesideCli(name, cliUrl = import.meta.url) {
+  const copy = pinnedPackageBesideCli(name, cliUrl);
+  return copy?.resolution === "entry" ? createRequire(cliUrl)(copy.path) : null;
+}
+function runNpm(args, signal) {
+  const npm = buildNpmCommand(args);
+  const child = spawn(npm.command, npm.args, { stdio: ["ignore", "pipe", "pipe"], signal });
+  return new Promise((resolve, reject) => {
+    let output = "";
+    child.stdout.on("data", (chunk) => output += chunk);
+    child.stderr.on("data", (chunk) => output += chunk);
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code) => code === 0 ? resolve() : reject(new Error(output || `npm exited with code ${code}`))
+    );
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+var STAGING_PID_TRUSTED_FOR_MS = 6 * 60 * 60 * 1e3;
+function sweepStaleStaging(dir) {
+  const prefix = `${basename(dir)}.tmp-`;
+  const parent = dirname(dir);
+  if (!existsSync(parent)) return;
+  for (const entry of readdirSync(parent)) {
+    if (!entry.startsWith(prefix)) continue;
+    const pid = /^(\d+)(?:-|$)/.exec(entry.slice(prefix.length))?.[1];
+    if (pid === void 0) continue;
+    const stale = join(parent, entry);
+    const age = Date.now() - (statSync(stale, { throwIfNoEntry: false })?.mtimeMs ?? Date.now());
+    if (isProcessAlive(Number(pid)) && age < STAGING_PID_TRUSTED_FOR_MS) continue;
+    try {
+      rmSync(stale, { recursive: true, force: true });
+    } catch (err) {
+      console.error(`could not remove stale install dir ${stale}: ${err.message}`);
+    }
+  }
+}
+async function install(dir, name, version, run = runNpm) {
+  sweepStaleStaging(dir);
+  const staging = `${dir}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+  mkdirSync(staging, { recursive: true });
+  writeFileSync(join(staging, "package.json"), "{}");
+  try {
+    await run([
+      "install",
+      `${name}@${version}`,
+      "--prefix",
+      staging,
+      "--no-audit",
+      "--no-fund",
+      "--loglevel=error",
+      // A first-use install is interactive, not a CI resolve: fail fast and name the
+      // manual command instead of sitting through npm's default multi-minute backoff.
+      "--fetch-retries=0",
+      "--fetch-timeout=20000"
+    ]);
+    if (isInstalled(dir, name)) return;
+    rmSync(dir, { recursive: true, force: true });
+    renameSync(staging, dir);
+  } catch (err) {
+    if (!isInstalled(dir, name)) throw err;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+var defaultDeps = {
+  cacheDir: CACHE_DIR,
+  loadBesideCli: (name) => name === "sharp" ? null : loadBesideCli(name),
+  loadInstalled,
+  install,
+  log: (line) => console.error(line)
+};
+
+export {
+  OPTIONAL_PACKAGES,
+  PINNED_PACKAGES,
+  CACHE_DIR,
+  installedOptionalPackageVersion,
+  loadInstalledOptionalPackage,
+  loadOptionalPackage,
+  loadSharp,
+  loadSharpInBackground,
+  loadInstalledSharp,
+  isInstalled,
+  installedPackagePath,
+  pinnedPackageBesideCli,
+  runNpm,
+  sweepStaleStaging,
+  install
+};

package/vendor/framey/dist/chunk-VORQIH64.js

@@ -0,0 +1,108 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-M2WBOQ2Q.js";
+
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported2 = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported2) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/ui/colors.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var isColorSupported = process.stdout.isTTY === true && !process.env["NO_COLOR"] && process.env["FORCE_COLOR"] !== "0";
+function wrap(fn) {
+  return isColorSupported ? fn : (s) => s;
+}
+var teal = (s) => `\x1B[38;2;60;230;172m${s}\x1B[39m`;
+var c = {
+  success: wrap(import_picocolors.default.green),
+  error: wrap(import_picocolors.default.red),
+  warn: wrap(import_picocolors.default.yellow),
+  dim: wrap(import_picocolors.default.dim),
+  bold: wrap(import_picocolors.default.bold),
+  accent: wrap(teal),
+  cyan: wrap(import_picocolors.default.cyan),
+  gray: wrap(import_picocolors.default.gray),
+  progress: wrap(import_picocolors.default.magenta),
+  reset: isColorSupported ? import_picocolors.default.reset : (s) => s
+};
+
+export {
+  isColorSupported,
+  c
+};

package/vendor/framey/dist/chunk-VTXFRIHO.js

@@ -0,0 +1,186 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  addCatchUpNote,
+  markSeen,
+  readSeen,
+  writeRecord
+} from "./chunk-VFZ7W5W7.js";
+import {
+  createProjectConfig
+} from "./chunk-4BNN5FGX.js";
+import {
+  isHyperframesProject
+} from "./chunk-DLA44CMS.js";
+
+// src/utils/desktopApp.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { basename, isAbsolute, join, relative, win32 } from "path";
+var DESKTOP_BUNDLE_IDS = ["dev.hyperframes.desktop", "dev.hyperframes.desktop.canary"];
+var DESKTOP_APP_NAMES = ["HyperFrames.app", "HyperFrames Canary.app"];
+var APP_NAMES = ["HyperFrames", "HyperFrames Canary"];
+var STUDIO_PAGE = "https://hyperframes.dev/studio";
+var DOWNLOADS = {
+  darwin: `${STUDIO_PAGE}/download`,
+  linux: `${STUDIO_PAGE}/download?os=linux`
+};
+var desktopDownloadUrl = (platform = process.platform) => DOWNLOADS[platform] ?? null;
+var downloadHint = (url) => `Keep editing by chatting with Framey in the HyperFrames desktop app \u2192 ${url}`;
+var HANDOFF_READY = process.platform === "darwin";
+var AGENT_HANDOFF_FILE = join(".hyperframes", "agent-handoff.json");
+var DESKTOP_CTA_RECORD = "desktop-cta.json";
+function agentSession(env = process.env) {
+  if (env.CLAUDE_CODE_SESSION_ID)
+    return { engine: "claude", sessionId: env.CLAUDE_CODE_SESSION_ID };
+  if (env.CODEX_THREAD_ID) return { engine: "codex", sessionId: env.CODEX_THREAD_ID };
+  if (env.GROK_SESSION_ID) return { engine: "grok", sessionId: env.GROK_SESSION_ID };
+  return null;
+}
+var openWithBundle = (bundleId, dir) => spawnSync("open", ["-b", bundleId, dir], { stdio: "ignore" }).status === 0;
+function launchApp(executable, dir) {
+  try {
+    const child = spawn(executable, [dir], { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var readText = (path) => {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+};
+function launcherAppImage(text) {
+  try {
+    const launcher = JSON.parse(text ?? "null");
+    return typeof launcher === "object" && launcher !== null && "appImage" in launcher && typeof launcher.appImage === "string" ? launcher.appImage : null;
+  } catch {
+    return null;
+  }
+}
+function desktopApps({
+  platform = process.platform,
+  env = process.env,
+  home = homedir(),
+  exists = existsSync,
+  read = readText
+} = {}) {
+  if (platform !== "win32" && platform !== "linux") return null;
+  const config = env.XDG_CONFIG_HOME || join(home, ".config");
+  const where = (name) => {
+    if (platform === "win32")
+      return env.LOCALAPPDATA ? win32.join(env.LOCALAPPDATA, "Programs", name, `${name}.exe`) : null;
+    const appImage = launcherAppImage(read(join(config, name, "launcher.json")));
+    return appImage && isAbsolute(appImage) ? appImage : null;
+  };
+  return APP_NAMES.flatMap((name, i) => {
+    const executable = where(name);
+    return executable && exists(executable) ? [{ executable, canary: i === 1 }] : [];
+  });
+}
+function leaveHandoff(dir, session) {
+  if (!session || !writeRecord(dir, "agent-handoff.json", JSON.stringify(session))) return null;
+  const now = Date.now();
+  if (!readSeen(dir).at && !markSeen(dir, { at: now, checked: now }))
+    console.warn("\u25C7  Couldn't note the hand-off in ~/.hyperframes, so `catch-up` won't see it.");
+  addCatchUpNote(dir);
+  return session;
+}
+function markBareIndexAsProject(dir) {
+  try {
+    if (existsSync(join(dir, "index.html")) && !isHyperframesProject(readdirSync(dir)))
+      createProjectConfig(dir);
+  } catch (error) {
+    console.warn(
+      `\u25C7  Couldn't add hyperframes.json to ${dir}, so the app may not open it: ${error}`
+    );
+  }
+}
+function openInDesktop(dir, {
+  ready = HANDOFF_READY,
+  platform = process.platform,
+  open = openWithBundle,
+  launch = launchApp,
+  installed = () => desktopInstalled({ platform }),
+  env = process.env,
+  cta,
+  ...where
+} = {}) {
+  const notOpened = (reason) => ({
+    opened: false,
+    reason,
+    downloadUrl: desktopDownloadUrl(platform) ?? STUDIO_PAGE
+  });
+  const opened = (canary) => {
+    if (cta) writeRecord(dir, DESKTOP_CTA_RECORD, JSON.stringify({ cta, at: Date.now() }));
+    return {
+      opened: true,
+      app: canary ? "HyperFrames Canary" : "the HyperFrames desktop app",
+      handedOver: leaveHandoff(dir, agentSession(env))
+    };
+  };
+  if (!ready) return notOpened("handoff-unavailable");
+  markBareIndexAsProject(dir);
+  if (platform === "darwin") {
+    const bundleId = DESKTOP_BUNDLE_IDS.find((id) => open(id, dir));
+    if (!bundleId) return notOpened(installed() ? "open-failed" : "not-installed");
+    return opened(bundleId.endsWith(".canary"));
+  }
+  const apps = desktopApps({ platform, env, ...where });
+  if (!apps) return notOpened("unsupported-platform");
+  if (!apps.length) return notOpened("not-installed");
+  const app = apps.find(({ executable }) => launch(executable, dir));
+  return app ? opened(app.canary) : notOpened("open-failed");
+}
+function openCommandFor(dir, cwd = process.cwd()) {
+  const shown = relative(cwd, dir) || ".";
+  return `framey open ${/\s/.test(shown) ? JSON.stringify(shown) : shown}`;
+}
+var spotlightFinds = (bundleId) => spawnSync("mdfind", [`kMDItemCFBundleIdentifier == '${bundleId}'`], { encoding: "utf8" }).stdout?.split("\n").some((path) => path.endsWith(".app") && !basename(path).startsWith(".")) ?? false;
+function desktopInstalled({
+  spotlight = spotlightFinds,
+  ...where
+} = {}) {
+  const { platform = process.platform, home = homedir(), exists = existsSync } = where;
+  if (platform !== "darwin") return (desktopApps(where)?.length ?? 0) > 0;
+  const folders = ["/Applications", join(home, "Applications")];
+  if (folders.some((folder) => DESKTOP_APP_NAMES.some((name) => exists(join(folder, name)))))
+    return true;
+  return DESKTOP_BUNDLE_IDS.some(spotlight);
+}
+function insideHostApp(env = process.env) {
+  return Boolean(env.HYPERFRAMES_DESKTOP_PROJECT);
+}
+function desktopHint(dir, {
+  env = process.env,
+  ready = HANDOFF_READY,
+  installed,
+  platform = process.platform
+} = {}) {
+  if (insideHostApp(env)) return null;
+  if (ready && (installed ?? desktopInstalled({ platform, env })))
+    return `Keep editing by chatting with Framey in the desktop app: ${openCommandFor(dir)}`;
+  const url = desktopDownloadUrl(platform);
+  return url ? downloadHint(url) : null;
+}
+
+export {
+  desktopDownloadUrl,
+  downloadHint,
+  HANDOFF_READY,
+  openInDesktop,
+  desktopInstalled,
+  insideHostApp,
+  desktopHint
+};