Files
hyperframes/packages/cli/src/utils/desktopApp.test.ts
T
Miguel Ángel a2e7306b2f fix(cli): open starts the desktop app in the home folder, not the folder it runs in (#7937)
* fix(cli): open starts the desktop app in the home folder, not the folder it runs in

* style(cli): keep launchApp's note on one comment line

* fix(cli): open starts the desktop app without the project's .env values
2026-11-16 10:53:40 +00:00

616 lines
25 KiB
TypeScript

import {
chmodSync,
existsSync,
mkdirSync,
mkdtempSync,
readdirSync,
readFileSync,
realpathSync,
rmSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve, win32 } from "node:path";
import { isHyperframesProject } from "@hyperframes/core";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { readSeen } from "./appHistory.js";
import { loadProjectDotEnv } from "./dotEnv.js";
import {
AGENT_HANDOFF_FILE,
agentSession,
desktopHint,
desktopInstalled,
openCommandFor,
openInDesktop,
previewStopCommandFor,
} from "./desktopApp.js";
const LIVE = { ready: true, platform: "darwin" as const, env: {}, installed: () => true };
const MAC_DOWNLOAD = "https://hyperframes.studio/studio/download?src=cli";
const MAC_HINT = `Keep editing by chatting with Framey in the HyperFrames desktop app → ${MAC_DOWNLOAD}`;
const FILM = resolve("films", "a");
const never = () => {
throw new Error("must not run");
};
afterEach(() => vi.unstubAllEnvs());
describe("openInDesktop", () => {
it("opens and writes nothing while the app cannot take a project", () => {
expect(openInDesktop(FILM, { ready: false, platform: "darwin", open: never })).toEqual({
opened: false,
reason: "handoff-unavailable",
downloadUrl: MAC_DOWNLOAD,
});
});
it("hands the folder to the Windows app on its command line, with no override", () => {
const launched: string[] = [];
const result = openInDesktop(FILM, {
platform: "win32",
env: { LOCALAPPDATA: "C:\\Users\\a\\AppData\\Local" },
exists: () => true,
launch: (executable, dir) => (launched.push(`${executable} ${dir}`), true),
});
expect(result).toMatchObject({ opened: true, app: "the HyperFrames desktop app" });
expect(launched).toEqual([
`C:\\Users\\a\\AppData\\Local\\Programs\\HyperFrames\\HyperFrames.exe ${FILM}`,
]);
});
it("hands the folder to the Linux AppImage on its command line, with no override", () => {
const launched: string[] = [];
const result = openInDesktop(FILM, {
platform: "linux",
env: {},
home: "/home/a",
exists: () => true,
read: () => JSON.stringify({ appImage: "/opt/HyperFrames.AppImage" }),
launch: (executable, dir) => (launched.push(`${executable} ${dir}`), true),
});
expect(result).toMatchObject({ opened: true, app: "the HyperFrames desktop app" });
expect(launched).toEqual([`/opt/HyperFrames.AppImage ${FILM}`]);
});
it("hands the folder to the released app when it is installed", () => {
const asked: string[] = [];
const result = openInDesktop(FILM, {
...LIVE,
open: (id, dir) => (asked.push(`${id} ${dir}`), true),
});
expect(result).toEqual({ opened: true, app: "the HyperFrames desktop app", handedOver: null });
expect(asked).toEqual([`dev.hyperframes.desktop ${FILM}`]);
});
it("hands over a folder preview serves from a bare index.html as a project the app accepts", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-bare-"));
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
let marked: boolean | null = null;
const result = openInDesktop(dir, {
...LIVE,
open: (_id, folder) => ((marked = isHyperframesProject(readdirSync(folder))), true),
});
expect(result).toMatchObject({ opened: true });
expect(marked).toBe(true);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("leaves the press's page id for the app only when the app took the folder", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-cta-"));
const record = join(dir, ".hyperframes", "desktop-cta.json");
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
openInDesktop(dir, { ...LIVE, cta: "page-1", open: () => false, installed: () => false });
expect(existsSync(record)).toBe(false);
openInDesktop(dir, { ...LIVE, cta: "page-1", open: () => true });
expect(JSON.parse(readFileSync(record, "utf8"))).toMatchObject({ cta: "page-1" });
expect(JSON.parse(readFileSync(record, "utf8"))).not.toHaveProperty("doc");
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("tells the app to open on the storyboard when the press came from the Storyboard tab", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-cta-doc-"));
const record = join(dir, ".hyperframes", "desktop-cta.json");
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
openInDesktop(dir, { ...LIVE, cta: "page-1", doc: "storyboard", open: () => true });
expect(JSON.parse(readFileSync(record, "utf8"))).toMatchObject({
cta: "page-1",
doc: "storyboard",
});
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("has the storyboard ask in place when the app is handed the folder, not after", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-cta-order-"));
const record = join(dir, ".hyperframes", "desktop-cta.json");
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
let seen: unknown = null;
openInDesktop(dir, {
...LIVE,
cta: "page-1",
doc: "storyboard",
open: () => {
seen = JSON.parse(readFileSync(record, "utf8"));
return true;
},
});
expect(seen).toMatchObject({ cta: "page-1", doc: "storyboard" });
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("doesn't reuse an earlier storyboard ask on a later header or plain open", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-cta-later-"));
const record = join(dir, ".hyperframes", "desktop-cta.json");
const read = () => JSON.parse(readFileSync(record, "utf8"));
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
openInDesktop(dir, { ...LIVE, cta: "page-1", doc: "storyboard", open: () => true });
let seen: unknown = null;
openInDesktop(dir, { ...LIVE, cta: "page-2", open: () => ((seen = read()), true) });
expect(seen).toMatchObject({ cta: "page-2" });
expect(seen).not.toHaveProperty("doc");
openInDesktop(dir, { ...LIVE, cta: "page-1", doc: "storyboard", open: () => true });
openInDesktop(dir, { ...LIVE, open: () => ((seen = read()), true) });
expect(seen).toMatchObject({ cta: "page-1" });
expect(seen).not.toHaveProperty("doc");
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("puts the earlier record back when the app didn't take the folder", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-cta-undo-"));
const record = join(dir, ".hyperframes", "desktop-cta.json");
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
openInDesktop(dir, { ...LIVE, cta: "page-1", open: () => true });
const earlier = readFileSync(record, "utf8");
openInDesktop(dir, {
...LIVE,
cta: "page-2",
doc: "storyboard",
open: () => false,
installed: () => true,
});
expect(readFileSync(record, "utf8")).toBe(earlier);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("leaves a project's own marker file alone", () => {
const dir = mkdtempSync(join(tmpdir(), "hf-marked-"));
try {
writeFileSync(join(dir, "index.html"), "<html></html>");
writeFileSync(join(dir, "meta.json"), "{}");
openInDesktop(dir, { ...LIVE, open: () => true });
expect(existsSync(join(dir, "hyperframes.json"))).toBe(false);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("looks only for the released app unless other builds are configured", () => {
const asked: string[] = [];
const result = openInDesktop(FILM, {
...LIVE,
installed: () => false,
open: (id) => (asked.push(id), false),
});
expect(asked).toEqual(["dev.hyperframes.desktop"]);
expect(result).toMatchObject({ opened: false, reason: "not-installed" });
});
it("falls back to a configured build when the released app is not installed", () => {
vi.stubEnv("HYPERFRAMES_DESKTOP_BUNDLE_IDS", "dev.hyperframes.desktop.next");
const result = openInDesktop(FILM, { ...LIVE, open: (id) => id.endsWith(".next") });
expect(result).toMatchObject({ opened: true, app: "dev.hyperframes.desktop.next" });
});
it("tells a missing app from one macOS could not open", () => {
const missing = openInDesktop(FILM, { ...LIVE, open: () => false, installed: () => false });
expect(missing).toMatchObject({ opened: false, reason: "not-installed" });
const failed = openInDesktop(FILM, { ...LIVE, open: () => false, installed: () => true });
expect(failed).toMatchObject({ opened: false, reason: "open-failed" });
});
it("opens nothing where the app has no build, and offers the app's page", () => {
expect(
openInDesktop(FILM, { ...LIVE, platform: "freebsd", open: never, launch: never }),
).toEqual({
opened: false,
reason: "unsupported-platform",
downloadUrl: "https://hyperframes.studio/studio",
});
});
});
describe("openInDesktop on Windows", () => {
const local = win32.join("C:", "Users", "a", "AppData", "Local");
const exe = (name: string) => win32.join(local, "Programs", name, `${name}.exe`);
const WIN = { ...LIVE, platform: "win32" as const, env: { LOCALAPPDATA: local }, open: never };
it("starts the installed app with the folder, released build first", () => {
const started: string[] = [];
const launch = (executable: string, dir: string) => (
started.push(`${executable} ${dir}`), true
);
const result = openInDesktop(FILM, { ...WIN, exists: () => true, launch });
expect(result).toEqual({ opened: true, app: "the HyperFrames desktop app", handedOver: null });
expect(started).toEqual([`${exe("HyperFrames")} ${FILM}`]);
});
it("finds a configured build only when it is named", () => {
const next = exe("HyperFrames Next");
const opts = { ...WIN, exists: (p: string) => p === next, launch: () => true };
expect(openInDesktop(FILM, opts)).toMatchObject({ opened: false, reason: "not-installed" });
vi.stubEnv("HYPERFRAMES_DESKTOP_APP_NAMES", "HyperFrames Next");
expect(openInDesktop(FILM, opts)).toMatchObject({ opened: true, app: "HyperFrames Next" });
});
it("tells a missing app from one that would not start, and offers the app's page", () => {
const missing = openInDesktop(FILM, { ...WIN, exists: () => false, launch: never });
expect(missing).toEqual({
opened: false,
reason: "not-installed",
downloadUrl: "https://hyperframes.studio/studio/download?os=windows&src=cli",
});
const failed = openInDesktop(FILM, { ...WIN, exists: () => true, launch: () => false });
expect(failed).toMatchObject({ opened: false, reason: "open-failed" });
});
});
describe("openInDesktop on Linux", () => {
const home = resolve("home", "a");
const appImage = resolve("opt", "HyperFrames-x86_64.AppImage");
const launcher = (name: string) => join(home, ".config", name, "launcher.json");
const LINUX = { ...LIVE, platform: "linux" as const, home, open: never, exists: () => true };
it("starts the AppImage the app last recorded in its launcher.json", () => {
vi.stubEnv("HYPERFRAMES_DESKTOP_APP_NAMES", "HyperFrames Next");
const files = { [launcher("HyperFrames Next")]: JSON.stringify({ appImage }) };
const started: string[] = [];
const result = openInDesktop(FILM, {
...LINUX,
read: (p) => files[p] ?? null,
launch: (executable, dir) => (started.push(`${executable} ${dir}`), true),
});
expect(result).toMatchObject({ opened: true, app: "HyperFrames Next" });
expect(started).toEqual([`${appImage} ${FILM}`]);
});
it("reads launcher.json under XDG_CONFIG_HOME when it is set", () => {
const config = resolve("xdg");
const read = (p: string) =>
p === join(config, "HyperFrames", "launcher.json") ? JSON.stringify({ appImage }) : null;
const env = { XDG_CONFIG_HOME: config };
expect(openInDesktop(FILM, { ...LINUX, env, read, launch: () => true })).toMatchObject({
opened: true,
app: "the HyperFrames desktop app",
});
});
it.skipIf(process.platform === "win32")(
"starts the app in the home folder, not the folder the command runs in",
async () => {
const dir = mkdtempSync(join(tmpdir(), "open-from-home-"));
const realHome = join(dir, "home");
mkdirSync(realHome);
const startedIn = join(dir, "started-in");
const app = join(dir, "HyperFrames.AppImage");
writeFileSync(app, `#!/bin/sh\npwd -P > ${JSON.stringify(startedIn)}\n`);
chmodSync(app, 0o755);
vi.stubEnv("HOME", realHome);
const files = { [launcher("HyperFrames")]: JSON.stringify({ appImage: app }) };
try {
expect(openInDesktop(FILM, { ...LINUX, read: (p) => files[p] ?? null })).toMatchObject({
opened: true,
});
await vi.waitFor(() =>
expect(readFileSync(startedIn, "utf8").trim()).toBe(realpathSync(realHome)),
);
} finally {
rmSync(dir, { recursive: true, force: true });
}
},
);
it.skipIf(process.platform === "win32")(
"starts the app without the values the project's .env set, keeping the person's own",
async () => {
const dir = mkdtempSync(join(tmpdir(), "open-env-"));
const seen = join(dir, "seen");
const app = join(dir, "HyperFrames.AppImage");
writeFileSync(
app,
`#!/bin/sh\nprintf '%s|%s' "\${HEYGEN_API_KEY-unset}" "\${ELEVENLABS_API_KEY-unset}" > ${JSON.stringify(seen)}\n`,
);
chmodSync(app, 0o755);
writeFileSync(
join(dir, ".env"),
"HEYGEN_API_KEY=from-project\nELEVENLABS_API_KEY=from-project\n",
);
vi.stubEnv("ELEVENLABS_API_KEY", "the-person's");
const before = process.env.HEYGEN_API_KEY;
delete process.env.HEYGEN_API_KEY;
loadProjectDotEnv(dir, process.env, () => {});
const files = { [launcher("HyperFrames")]: JSON.stringify({ appImage: app }) };
try {
expect(process.env.HEYGEN_API_KEY).toBe("from-project");
expect(openInDesktop(FILM, { ...LINUX, read: (p) => files[p] ?? null })).toMatchObject({
opened: true,
});
await vi.waitFor(() => expect(readFileSync(seen, "utf8")).toBe("unset|the-person's"));
} finally {
if (before === undefined) delete process.env.HEYGEN_API_KEY;
else process.env.HEYGEN_API_KEY = before;
rmSync(dir, { recursive: true, force: true });
}
},
);
it("ignores a relative, moved, or unreadable AppImage path", () => {
const relativeFile = { [launcher("HyperFrames")]: JSON.stringify({ appImage: "HF.AppImage" }) };
const relativePath = { ...LINUX, read: (p: string) => relativeFile[p] ?? null, launch: never };
expect(openInDesktop(FILM, relativePath)).toMatchObject({ reason: "not-installed" });
const moved = { [launcher("HyperFrames")]: JSON.stringify({ appImage }) };
const gone = { ...LINUX, read: (p: string) => moved[p] ?? null, exists: () => false };
expect(openInDesktop(FILM, { ...gone, launch: never })).toMatchObject({
reason: "not-installed",
downloadUrl: "https://hyperframes.studio/studio/download?os=linux&src=cli",
});
expect(openInDesktop(FILM, { ...LINUX, read: () => "{", launch: never })).toMatchObject({
reason: "not-installed",
});
});
});
describe("agent hand-off", () => {
// The seen record lives in the person's home: these tests get their own.
beforeEach(() => {
const home = mkdtempSync(join(tmpdir(), "hf-home-"));
vi.stubEnv("HOME", home);
vi.stubEnv("USERPROFILE", home);
return () => vi.unstubAllEnvs();
});
let dir: string | undefined;
afterEach(() => {
if (dir) chmodSync(dir, 0o755);
if (dir) rmSync(dir, { recursive: true, force: true });
});
const handoff = () => join(dir!, AGENT_HANDOFF_FILE);
it("names the conversation the command runs in, Claude Code first", () => {
expect(agentSession({ CLAUDE_CODE_SESSION_ID: "c-1", CODEX_THREAD_ID: "x-1" })).toEqual({
engine: "claude",
sessionId: "c-1",
});
expect(agentSession({ CODEX_THREAD_ID: "x-1" })).toEqual({ engine: "codex", sessionId: "x-1" });
expect(agentSession({ GROK_SESSION_ID: "g-1" })).toEqual({ engine: "grok", sessionId: "g-1" });
expect(agentSession({})).toBeNull();
});
it("leaves the app the conversation once it has the folder", () => {
dir = mkdtempSync(join(tmpdir(), "hf-handoff-"));
writeFileSync(join(dir, "CLAUDE.md"), "# HyperFrames Composition Project\n");
const session = "0a8eed95-0869-45bf-83ec-5d71fcc5236c";
const result = openInDesktop(dir, {
...LIVE,
open: () => true,
env: { CLAUDE_CODE_SESSION_ID: session },
});
expect(result).toMatchObject({ opened: true, handedOver: { engine: "claude" } });
expect(JSON.parse(readFileSync(handoff(), "utf8"))).toEqual({
engine: "claude",
sessionId: session,
});
// `catch-up` shows only what the app does from here on.
const first = readSeen(dir).at;
expect(first).toBeGreaterThan(Date.now() - 60_000);
// Handing it over again keeps the turns recorded since the first hand-off for catch-up.
openInDesktop(dir, { ...LIVE, open: () => true, env: { CLAUDE_CODE_SESSION_ID: session } });
expect(readSeen(dir).at).toBe(first);
expect(readFileSync(join(dir, "CLAUDE.md"), "utf8")).toContain("npx hyperframes catch-up");
});
it("writes nothing when gated, when no app took the folder, or when no agent runs the command", () => {
dir = mkdtempSync(join(tmpdir(), "hf-handoff-"));
const agent = { CODEX_THREAD_ID: "x-1" };
openInDesktop(dir, { ready: false, platform: "darwin", open: never, env: agent });
openInDesktop(dir, { ...LIVE, open: () => false, env: agent });
openInDesktop(dir, { ...LIVE, open: () => true });
expect(existsSync(handoff())).toBe(false);
});
it.skipIf(process.platform === "win32")(
"still opens a project it cannot write to, with nothing handed over",
() => {
dir = mkdtempSync(join(tmpdir(), "hf-handoff-"));
chmodSync(dir, 0o555);
const result = openInDesktop(dir, {
...LIVE,
open: () => true,
env: { CODEX_THREAD_ID: "x-1" },
});
expect(result).toMatchObject({ opened: true, handedOver: null });
},
);
});
describe("openCommandFor", () => {
it("names the project relative to where the person is", () => {
const work = resolve("work");
expect(openCommandFor(join(work, "films", "a"), join(work, "films", "a"))).toBe(
"hyperframes open .",
);
expect(openCommandFor(join(work, "films", "a"), work)).toBe(
process.platform === "win32" ? 'hyperframes open "films\\a"' : "hyperframes open films/a",
);
expect(openCommandFor(join(work, "my film"), work)).toBe('hyperframes open "my film"');
});
it("spells a Windows folder so PowerShell and Git Bash run no part of its name", () => {
const work = resolve("work");
expect(openCommandFor(join(work, "$(calc)"), work, "win32")).toBe(
"hyperframes open from the project folder",
);
expect(openCommandFor(join(work, "$(calc)&calc"), work, "win32")).toBe(
"hyperframes open from the project folder",
);
});
it("has no Windows stop command for a folder with no safe spelling", () => {
const work = resolve("work");
expect(previewStopCommandFor(join(work, "$(calc)&calc"), 3002, work, "win32")).toBeNull();
});
it("names the matching `preview --stop` the same way", () => {
const work = resolve("work");
expect(previewStopCommandFor(work, 3002, work)).toBe(
"hyperframes preview . --stop --port 3002",
);
expect(previewStopCommandFor(join(work, "my film"), 4567, work)).toBe(
'hyperframes preview "my film" --stop --port 4567',
);
});
});
describe("desktopInstalled", () => {
const home = resolve("Users", "a");
const nothing = {
platform: "darwin" as const,
home,
exists: () => false,
spotlight: () => false,
};
it("finds the app where the DMG and the installer put it", () => {
const system = join("/Applications", "HyperFrames.app");
expect(desktopInstalled({ ...nothing, exists: (p: string) => p === system })).toBe(true);
const mine = join(home, "Applications", "HyperFrames.app");
expect(desktopInstalled({ ...nothing, exists: (p: string) => p === mine })).toBe(true);
});
it("asks Spotlight for one installed anywhere else", () => {
expect(
desktopInstalled({ ...nothing, spotlight: (id: string) => id === "dev.hyperframes.desktop" }),
).toBe(true);
expect(desktopInstalled(nothing)).toBe(false);
});
it("finds the Windows app where its installer puts it, and nothing where there is no build", () => {
const local = win32.join("C:", "Users", "a", "AppData", "Local");
const app = win32.join(local, "Programs", "HyperFrames", "HyperFrames.exe");
const windows = { ...nothing, platform: "win32" as const, env: { LOCALAPPDATA: local } };
expect(desktopInstalled({ ...windows, exists: (p: string) => p === app })).toBe(true);
expect(desktopInstalled(windows)).toBe(false);
expect(desktopInstalled({ ...nothing, platform: "freebsd", exists: () => true })).toBe(false);
});
it("finds no Linux app that never recorded its AppImage", () => {
const linux = { ...nothing, platform: "linux" as const, exists: () => true, read: () => null };
expect(desktopInstalled(linux)).toBe(false);
});
});
describe("desktopHint", () => {
const mac = { env: {}, platform: "darwin" as const, tty: true };
it("points to the download while gated, and when the app is missing", () => {
expect(desktopHint(process.cwd(), { ...mac, ready: false, installed: true })).toBe(MAC_HINT);
expect(desktopHint(process.cwd(), { ...mac, ready: true, installed: false })).toBe(MAC_HINT);
});
it("offers the Linux and Windows builds there, and nothing where there is no build", () => {
expect(
desktopHint(process.cwd(), { env: {}, platform: "linux", installed: false, tty: true }),
).toBe(
`Keep editing by chatting with Framey in the HyperFrames desktop app → https://hyperframes.studio/studio/download?os=linux&src=cli`,
);
const windowsHint = `Keep editing by chatting with Framey in the HyperFrames desktop app → https://hyperframes.studio/studio/download?os=windows&src=cli`;
expect(
desktopHint(process.cwd(), { env: {}, platform: "win32", installed: false, tty: true }),
).toBe(windowsHint);
expect(desktopHint(process.cwd(), { env: {}, platform: "win32", ready: true, tty: true })).toBe(
windowsHint,
);
expect(
desktopHint(process.cwd(), { env: {}, platform: "freebsd", installed: false, tty: true }),
).toBeNull();
});
it("points an installed Windows app to `hyperframes open`", () => {
const windows = {
env: {},
platform: "win32" as const,
ready: true,
installed: true,
tty: true,
};
expect(desktopHint(process.cwd(), windows)).toBe(
"Keep editing by chatting with Framey in the desktop app: hyperframes open .",
);
});
it("points an installed app to `hyperframes open` once the app takes handed-over projects", () => {
expect(desktopHint(process.cwd(), { ...mac, ready: true, installed: true })).toBe(
"Keep editing by chatting with Framey in the desktop app: hyperframes open .",
);
});
it("tells a preview's reader that the app can't edit while the preview runs", () => {
const installed = { ...mac, ready: true, installed: true };
expect(desktopHint(process.cwd(), { ...installed, preview: "background" })).toBe(
"Keep editing by chatting with Framey in the desktop app: hyperframes open . (this stops the background preview)",
);
expect(desktopHint(process.cwd(), { ...installed, preview: "foreground" })).toBe(
"Keep editing by chatting with Framey in the desktop app: stop this preview, then run hyperframes open .",
);
expect(desktopHint(process.cwd(), { ...mac, installed: false, preview: "background" })).toBe(
MAC_HINT,
);
});
it("says nothing inside the app, whose runs carry HYPERFRAMES_DESKTOP_PROJECT", () => {
const inApp = {
...mac,
env: { HYPERFRAMES_DESKTOP_PROJECT: "/p" },
ready: true,
installed: true,
};
expect(desktopHint(process.cwd(), inApp)).toBeNull();
});
it("says nothing to CI or a script reading the output, where nobody can open the app", () => {
const installedMac = { ...mac, ready: true, installed: true };
expect(desktopHint(process.cwd(), { ...installedMac, env: { CI: "true" } })).toBeNull();
expect(desktopHint(process.cwd(), { ...installedMac, tty: false })).toBeNull();
});
it("still gives the line to a coding agent, which passes it on to the person", () => {
const agent = {
...mac,
ready: true,
installed: true,
tty: false,
env: { CLAUDE_CODE_CHILD_SESSION: "1" },
};
expect(desktopHint(process.cwd(), agent)).toBe(
"Keep editing by chatting with Framey in the desktop app: hyperframes open .",
);
});
});