fix(cli): every settings file follows HYPERFRAMES_CONFIG_DIR (#7229)

* fix(cli): every settings file follows HYPERFRAMES_CONFIG_DIR

* fix(cli): the media-use skill copy reads its config from HYPERFRAMES_CONFIG_DIR too

* test(cli): expect the config folder as a normalized path on every platform

* chore(skills): refresh the media-use manifest hash

* fix(cli): a moved settings folder starts from ~/.hyperframes, keeping an opt-out

* fix(cli): drop the updater's unused path import

* style(cli): keep the settings-seed comment under 120 characters
This commit is contained in:
Miguel Ángel
2026-11-05 11:34:36 +00:00
committed by GitHub
parent b7a8cfa73c
commit 216395e98e
19 changed files with 235 additions and 63 deletions
+1 -1
View File
@@ -147,7 +147,7 @@ to a shared space with `--space`.
| `HEYGEN_ACCESS_TOKEN` | OAuth token a host app injects; never refreshed or saved. |
| `HEYGEN_API_BASE` | A host app's gateway for media workflows; never read from a project `.env`. |
| `HEYGEN_API_URL` | API base URL for `hyperframes` CLI commands (default `https://api.heygen.com`). |
| `HYPERFRAMES_CONFIG_DIR` | HyperFrames credentials root (default `~/.hyperframes`). |
| `HYPERFRAMES_CONFIG_DIR` | HyperFrames settings root: credentials, telemetry and update settings, project links (default `~/.hyperframes`). |
| `HYPERFRAMES_ENV` | `prod` (default) or `dev`; `dev` keeps credentials in a separate `dev/` directory under the root. Hosts and the OAuth client id come from `HEYGEN_API_URL`, `HYPERFRAMES_OAUTH_*` and `HYPERFRAMES_PUBLISHED_PROJECTS_API_URL`. |
| `HYPERFRAMES_OAUTH_CLIENT_ID` | Override the public client ID for a controlled OAuth environment. |
| `ELEVENLABS_API_KEY` | ElevenLabs TTS, used when no HeyGen credential is present. |
+1 -1
View File
@@ -2516,7 +2516,7 @@ hyperframes auth logout --yes # no prompt
| `HYPERFRAMES_API_KEY` | Alias for `HEYGEN_API_KEY`. |
| `HEYGEN_ACCESS_TOKEN` | OAuth token from a host app; used first, never refreshed. |
| `HEYGEN_API_URL` | API base URL (default `https://api.heygen.com`). |
| `HYPERFRAMES_CONFIG_DIR` | Credentials root (default `~/.hyperframes`). |
| `HYPERFRAMES_CONFIG_DIR` | Settings root: credentials, telemetry and update settings, project links (default `~/.hyperframes`). |
| `HYPERFRAMES_ENV` | `prod` (default) or `dev`; `dev` uses a separate credential directory. Hosts and the OAuth client id come from `HEYGEN_API_URL` and `HYPERFRAMES_OAUTH_*`. |
| `HYPERFRAMES_OAUTH_CLIENT_ID` | Override the selected public OAuth client. |
+1 -1
View File
@@ -22,7 +22,7 @@ describe("auth/paths", () => {
it("honors HYPERFRAMES_CONFIG_DIR override", () => {
process.env["HYPERFRAMES_CONFIG_DIR"] = "/tmp/some-test-dir";
expect(configDir()).toBe("/tmp/some-test-dir");
expect(configDir()).toBe(join("/tmp/some-test-dir"));
expect(credentialPath()).toBe(join("/tmp/some-test-dir", CREDENTIAL_FILENAME));
});
+2 -2
View File
@@ -2,8 +2,8 @@
* HyperFrames credentials are isolated from the HeyGen CLI and between environments.
*/
import { homedir } from "node:os";
import { join } from "node:path";
import { hyperframesConfigDir } from "../utils/configDir.js";
import { oauthEnvironment } from "./config.js";
/**
@@ -12,7 +12,7 @@ import { oauthEnvironment } from "./config.js";
export const CREDENTIAL_FILENAME = "credentials";
export function configDir(): string {
const root = process.env["HYPERFRAMES_CONFIG_DIR"] || join(homedir(), ".hyperframes");
const root = hyperframesConfigDir();
return oauthEnvironment() === "dev" ? join(root, "dev") : root;
}
+3 -3
View File
@@ -16,7 +16,6 @@ import { CliUsageError, failCommand, failUsage } from "../utils/commandResult.js
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import { join, resolve } from "node:path";
import { defineCommand } from "../utils/defineCommand.js";
import { type CanvasResolution } from "@hyperframes/core";
@@ -32,6 +31,7 @@ import { normalizeErrorMessage } from "../utils/errorMessage.js";
import { defaultCloudFps } from "../utils/compositionFps.js";
import { DISTRIBUTED_FPS, type DistributedFps, isDistributedFps } from "@hyperframes/core";
import { isMissingPackageError, missingPackageMessage } from "../utils/missingPackage.js";
import { hyperframesConfigDir, seededConfigFile } from "../utils/configDir.js";
export const examples: Example[] = [
["Deploy the Cloud Run render stack", "hyperframes cloudrun deploy --project my-gcp-project"],
@@ -267,10 +267,10 @@ export default defineCommand({
// ── State helpers ─────────────────────────────────────────────────────────
function stateDir(): string {
return join(homedir(), ".hyperframes");
return hyperframesConfigDir();
}
function statePath(): string {
return join(stateDir(), "cloudrun-state.json");
return seededConfigFile("cloudrun-state.json");
}
function writeState(state: StackState): void {
mkdirSync(stateDir(), { recursive: true });
+6 -1
View File
@@ -50,8 +50,13 @@ export function optedOut() {
}
// Read and write the shared config so media-use keeps one identity per install.
// Until the CLI seeds HYPERFRAMES_CONFIG_DIR's copy, ~/.hyperframes' own still holds the opt-out.
function sharedConfigPath() {
return join(homedir(), ".hyperframes", "config.json");
const home = join(homedir(), ".hyperframes", "config.json");
const dir = process.env.HYPERFRAMES_CONFIG_DIR;
if (!dir) return home;
const file = join(dir, "config.json");
return existsSync(file) || !existsSync(home) ? file : home;
}
function readSharedConfig() {
@@ -79,6 +79,40 @@ test("optedOut honors telemetryEnabled: false from the shared config", () => {
}
});
test("the shared config is read from HYPERFRAMES_CONFIG_DIR when it is set", () => {
const savedEnv = { ...process.env };
const { root } = sandbox();
try {
withoutTelemetryOptOut();
const configDir = join(root, "config");
mkdirSync(configDir, { recursive: true });
writeFileSync(join(configDir, "config.json"), JSON.stringify({ telemetryEnabled: false }));
process.env.HYPERFRAMES_CONFIG_DIR = configDir;
assert.equal(optedOut(), true);
} finally {
restoreEnv(savedEnv);
rmSync(root, { recursive: true, force: true });
}
});
test("an opt-out in ~/.hyperframes holds until HYPERFRAMES_CONFIG_DIR has its own config", () => {
const savedEnv = { ...process.env };
const { root, home } = sandbox();
try {
withoutTelemetryOptOut();
mkdirSync(join(home, ".hyperframes"), { recursive: true });
writeFileSync(
join(home, ".hyperframes", "config.json"),
JSON.stringify({ telemetryEnabled: false }),
);
process.env.HYPERFRAMES_CONFIG_DIR = join(root, "moved");
assert.equal(optedOut(), true);
} finally {
restoreEnv(savedEnv);
rmSync(root, { recursive: true, force: true });
}
});
test("track is a no-op (no network, resolves) when opted out", async () => {
const savedEnv = { ...process.env };
const originalFetch = globalThis.fetch;
+24 -28
View File
@@ -7,26 +7,22 @@ import { normalizeErrorMessage } from "../utils/errorMessage.js";
import { telemetryRuntimeOverride } from "./policy.js";
import { isAttendedTerminal } from "../utils/attendedTerminal.js";
import { withFileLock } from "../media-use/lib/config-lock.mjs";
import { hyperframesConfigDir, seededConfigFile } from "../utils/configDir.js";
// ---------------------------------------------------------------------------
// Config directory: ~/.hyperframes/
// ---------------------------------------------------------------------------
const CONFIG_DIR = join(homedir(), ".hyperframes");
const CONFIG_FILE = join(CONFIG_DIR, "config.json");
const configDir = () => hyperframesConfigDir();
const configFile = () => seededConfigFile("config.json");
// ---------------------------------------------------------------------------
// Install-state file: ~/.hyperframes/install-state.json
//
// A separate FILE, but deliberately the same DIRECTORY as config.json, so
// `rm -rf ~/.hyperframes` really is a full reset. It previously lived in
// ~/.local/state/hyperframes/ specifically to survive that delete; review
// rejected that ("if someone is deleting their hyperframes config it should
// wipe all hyperframes state — I'm not sure we should try and persist state
// elsewhere to get around this"), and the measurement agreed: the churn this
// actually defends against is not users running `rm -rf`.
// `rm -rf ~/.hyperframes` really is a full reset.
//
// The threat it does defend against is config.json itself. That file is hot
// What it defends against is config.json itself. That file is hot
// and wide — ~20 fields rewritten on every command and every render — and
// readConfig recovers from ANY parse/permission/IO failure by minting a fresh
// identity. Splitting these two facts into their own file decouples them from
@@ -37,7 +33,7 @@ const CONFIG_FILE = join(CONFIG_DIR, "config.json");
// no counters, nothing emitted that links the old install to the new one:
//
// 1. `markerAt` — "a hyperframes install existed on this machine". Now that
// it shares CONFIG_DIR, `predecessorFound` measures the churn we care
// it shares configDir(), `predecessorFound` measures the churn we care
// about (config.json lost, install-state survived => corruption/re-mint)
// rather than deliberate directory deletion, which takes both.
// 2. `deParallelRouterTrialFired` — the DE parallel-router circuit
@@ -45,18 +41,18 @@ const CONFIG_FILE = join(CONFIG_DIR, "config.json");
// install into an experimental path that already FAILED on this machine.
// 3. `bucketSeed` — the canary bucketing unit, so a re-mint does not
// reshuffle cohorts mid-rollout. Never transmitted; only the resulting
// true/false assignments are. Sharing CONFIG_DIR is what keeps it from
// true/false assignments are. Sharing configDir() is what keeps it from
// being a persistent identifier that outlives the user's reset.
//
// Removal path: delete ~/.hyperframes (or just this file). `hyperframes
// telemetry status` prints its exact location.
// ---------------------------------------------------------------------------
const STATE_FILE = join(CONFIG_DIR, "install-state.json");
const stateFile = () => seededConfigFile("install-state.json");
// Pre-move location. Read once, migrated, then deleted — an install that
// wrote state under the old scheme keeps its tripped breaker instead of
// silently re-enrolling, and no file is left behind outside CONFIG_DIR.
// silently re-enrolling, and no file is left behind outside configDir().
const LEGACY_STATE_FILE = join(homedir(), ".local", "state", "hyperframes", "install-state.json");
interface InstallState {
@@ -231,7 +227,7 @@ function isInstallState(value: InstallState | InstallStateMiss): value is Instal
* re-read harmlessly next time.
*/
function readInstallState(): InstallState | InstallStateMiss {
const current = parseInstallState(STATE_FILE);
const current = parseInstallState(stateFile());
if (isInstallState(current)) {
removeLegacyStateFile();
return current;
@@ -281,10 +277,10 @@ export function __resetInstallStateSyncForTests(): void {
* since a corrupted state file silently reads as absent.
*/
function writeInstallState(next: InstallState): void {
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
const tmpFile = `${STATE_FILE}.${process.pid}.tmp`;
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
const tmpFile = `${stateFile()}.${process.pid}.tmp`;
writeFileSync(tmpFile, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
renameSync(tmpFile, STATE_FILE);
renameSync(tmpFile, stateFile());
}
/**
@@ -344,7 +340,7 @@ function syncInstallState(config: HyperframesConfig): boolean {
// the freshly minted seed lived in config.json alone, and the NEXT
// config-only re-mint rolled a third seed instead of inheriting the second.
// One existsSync on a path we are about to write anyway.
if (stateMarkerSynced && !existsSync(STATE_FILE)) {
if (stateMarkerSynced && !existsSync(stateFile())) {
stateMarkerSynced = false;
stateFiredSynced = false;
}
@@ -799,10 +795,10 @@ function materializeConfig(parsed: Partial<HyperframesConfig>): HyperframesConfi
export function readConfig(): HyperframesConfig {
if (cachedConfig) return { ...cachedConfig };
if (!existsSync(CONFIG_FILE)) return mintAndCacheConfig();
if (!existsSync(configFile())) return mintAndCacheConfig();
try {
const raw = readFileSync(CONFIG_FILE, "utf-8");
const raw = readFileSync(configFile(), "utf-8");
const parsed = JSON.parse(raw) as Partial<HyperframesConfig>;
const config = materializeConfig(parsed);
@@ -958,7 +954,7 @@ function consentFrom(value: unknown): boolean | undefined {
function localModelConsentOnDisk(): boolean | undefined {
try {
return consentFrom(JSON.parse(readFileSync(CONFIG_FILE, "utf-8")).localEmbeddingEnabled);
return consentFrom(JSON.parse(readFileSync(configFile(), "utf-8")).localEmbeddingEnabled);
} catch (error) {
// A settings file that exists but cannot be read may hold a no; only a missing one was never asked.
return (error as NodeJS.ErrnoException).code === "ENOENT" ? undefined : false;
@@ -970,8 +966,8 @@ let holdingConfigLock = false;
/** One process at a time between reading config.json and replacing it; re-entrant within this one. */
function withConfigLock<T>(task: () => T): T {
if (holdingConfigLock) return task();
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
return withFileLock(`${CONFIG_FILE}.lock`, fs, () => {
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
return withFileLock(`${configFile()}.lock`, fs, () => {
holdingConfigLock = true;
try {
return task();
@@ -983,10 +979,10 @@ function withConfigLock<T>(task: () => T): T {
function persistConfig(config: HyperframesConfig): ConfigWriteResult {
try {
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
const tmpFile = `${CONFIG_FILE}.${process.pid}.tmp`;
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
const tmpFile = `${configFile()}.${process.pid}.tmp`;
writeFileSync(tmpFile, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
renameSync(tmpFile, CONFIG_FILE);
renameSync(tmpFile, configFile());
cachedConfig = { ...config };
// Mirror into the install-state file (marker + tripped breaker) so no
// breaker write site has to remember to do it. A failed mirror does NOT
@@ -1013,7 +1009,7 @@ export function incrementCommandCount(): number {
}
/** Expose the config directory path for the telemetry command output */
export const CONFIG_PATH = CONFIG_FILE;
export const CONFIG_PATH = configFile();
/** Expose the install-state path for the telemetry command output. */
export const STATE_PATH = STATE_FILE;
export const STATE_PATH = stateFile();
@@ -43,6 +43,10 @@ async function patchAvailableAt(entry: string) {
VERSION: "0.8.231",
}));
vi.doMock("./env.js", () => ({ isDevMode: () => false }));
vi.doMock("./runningCli.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./runningCli.js")>()),
registeredAsRunning: () => true,
}));
vi.doMock("./attendedTerminal.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./attendedTerminal.js")>()),
isUnattended: () => false,
+18
View File
@@ -27,6 +27,7 @@ function setupMocks(opts: {
env?: Record<string, string | undefined>;
writeFails?: boolean;
unattended?: boolean;
registered?: boolean;
}): {
writeSpy: ReturnType<typeof vi.fn>;
spawnSpy: ReturnType<typeof vi.fn>;
@@ -51,6 +52,10 @@ function setupMocks(opts: {
writeConfig: writeSpy,
}));
vi.doMock("./env.js", () => ({ isDevMode: () => !!opts.devMode }));
vi.doMock("./runningCli.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./runningCli.js")>()),
registeredAsRunning: () => opts.registered ?? true,
}));
vi.doMock("./attendedTerminal.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./attendedTerminal.js")>()),
isUnattended: () => opts.unattended ?? false,
@@ -108,6 +113,7 @@ describe("scheduleBackgroundInstall", () => {
process.env = { ...ORIGINAL_ENV };
vi.doUnmock("../telemetry/config.js");
vi.doUnmock("./env.js");
vi.doUnmock("./runningCli.js");
vi.doUnmock("./installerDetection.js");
vi.doUnmock("node:child_process");
vi.doUnmock("node:fs");
@@ -129,6 +135,18 @@ describe("scheduleBackgroundInstall", () => {
expect(config.pendingUpdate?.command).toBe("npm install -g hyperframes@0.4.4");
});
it("schedules nothing from a CLI that could not put itself on record as running", async () => {
const { spawnSpy, writeSpy } = setupMocks({
installer: { kind: "npm", command: "npm install -g hyperframes@0.4.4" },
registered: false,
});
const { scheduleBackgroundInstall } = await import("./autoUpdate.js");
expect(scheduleBackgroundInstall("0.4.4", "0.4.3")).toBe(false);
expect(spawnSpy).not.toHaveBeenCalled();
expect(writeSpy).not.toHaveBeenCalled();
});
it("launches nothing when the pending install cannot be recorded", async () => {
const { spawnSpy } = setupMocks({
installer: { kind: "npm", command: "npm install -g hyperframes@0.4.4" },
+16 -11
View File
@@ -25,22 +25,21 @@
import { spawn } from "node:child_process";
import { appendFileSync, mkdirSync, openSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
import { compareVersions } from "compare-versions";
import { withFileLock } from "../media-use/lib/config-lock.mjs";
import { readConfig, writeConfig } from "../telemetry/config.js";
import { isUnattended } from "./attendedTerminal.js";
import { updateCheckDisabled } from "./updateCheck.js";
import { RUNNING_DIR, RUNNING_STALE_MS } from "./runningCli.js";
import { RUNNING_STALE_MS, registeredAsRunning, runningDir } from "./runningCli.js";
import {
detectInstaller,
installInvocation,
type InstallInvocation,
} from "./installerDetection.js";
import { hyperframesConfigDir, seededConfigFile } from "./configDir.js";
const CONFIG_DIR = join(homedir(), ".hyperframes");
const LOG_FILE = join(CONFIG_DIR, "auto-update.log");
const configDir = () => hyperframesConfigDir();
const logFile = () => hyperframesConfigDir("auto-update.log");
/** An install that hasn't finished after this many ms is considered stuck. */
const PENDING_TIMEOUT_MS = 10 * 60 * 1000;
/** A waiting installer gives up after this long; the next run schedules it again. */
@@ -66,8 +65,8 @@ function breakingLine(version: string): string | null {
*/
function log(line: string): void {
try {
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
appendFileSync(LOG_FILE, `${new Date().toISOString()} ${line}\n`, { mode: 0o600 });
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
appendFileSync(logFile(), `${new Date().toISOString()} ${line}\n`, { mode: 0o600 });
} catch {
/* best-effort */
}
@@ -207,21 +206,21 @@ function launchDetachedInstall(
displayCommand: string,
version: string,
): void {
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
const configFile = join(CONFIG_DIR, "config.json");
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
const configFile = seededConfigFile("config.json");
const nodeScript = installerScript({
configFile,
version,
bin: invocation.bin,
args: invocation.args,
runningDir: RUNNING_DIR,
runningDir: runningDir(),
pollMs: INSTALL_POLL_MS,
maxWaitMs: INSTALL_MAX_WAIT_MS,
staleMs: RUNNING_STALE_MS,
});
const out = openSync(LOG_FILE, "a", 0o600);
const out = openSync(logFile(), "a", 0o600);
const child = spawn(process.execPath, ["-e", nodeScript], {
detached: true,
stdio: ["ignore", out, out],
@@ -277,6 +276,12 @@ function backgroundInstaller(
export function scheduleBackgroundInstall(latestVersion: string, currentVersion: string): boolean {
if (isAutoInstallDisabled()) return false;
if (!isSilentUpgrade(latestVersion, currentVersion)) return false;
if (!registeredAsRunning()) {
log(
`[skip] ${latestVersion}: this CLI is not on record as running, so an install could replace it mid-run`,
);
return false;
}
const installer = backgroundInstaller(latestVersion);
if (!installer) return false;
+42
View File
@@ -0,0 +1,42 @@
import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, expect, it, vi } from "vitest";
import { credentialPath } from "../auth/paths.js";
import { readConfig, readConfigFresh, writeConfig } from "../telemetry/config.js";
import { hyperframesConfigDir } from "./configDir.js";
import { writeProjectLink } from "./projectLink.js";
import { runningDir } from "./runningCli.js";
let dir = "";
afterEach(() => {
vi.unstubAllEnvs();
rmSync(dir, { recursive: true, force: true });
});
it("keeps every config file under HYPERFRAMES_CONFIG_DIR when it is set", () => {
dir = mkdtempSync(join(tmpdir(), "hf-config-"));
vi.stubEnv("HYPERFRAMES_CONFIG_DIR", dir);
expect(hyperframesConfigDir("x")).toBe(join(dir, "x"));
expect(runningDir()).toBe(join(dir, "running"));
expect(credentialPath().startsWith(dir)).toBe(true);
expect(writeConfig(readConfig())).toBe(true);
expect(existsSync(join(dir, "config.json"))).toBe(true);
writeProjectLink(join(dir, "project"), { projectId: "p", url: "https://example.test/p" });
expect(existsSync(join(dir, "projects.json"))).toBe(true);
});
it("starts a new settings folder from ~/.hyperframes, so an opt-out and the install id move with it", () => {
dir = mkdtempSync(join(tmpdir(), "hf-config-"));
const home = join(dir, "home");
mkdirSync(join(home, ".hyperframes"), { recursive: true });
const old = { telemetryEnabled: false, anonymousId: "kept-id" };
writeFileSync(join(home, ".hyperframes", "config.json"), JSON.stringify(old));
vi.stubEnv("HOME", home);
vi.stubEnv("USERPROFILE", home);
vi.stubEnv("HYPERFRAMES_CONFIG_DIR", join(dir, "moved"));
const config = readConfigFresh();
expect(config.telemetryEnabled).toBe(false);
expect(config.anonymousId).toBe("kept-id");
expect(existsSync(join(dir, "moved", "config.json"))).toBe(true);
});
+23
View File
@@ -0,0 +1,23 @@
import { constants, copyFileSync, existsSync, mkdirSync } from "node:fs";
import { homedir } from "node:os";
import { dirname, join } from "node:path";
const homeConfigDir = () => join(homedir(), ".hyperframes");
export function hyperframesConfigDir(...parts: string[]): string {
return join(process.env["HYPERFRAMES_CONFIG_DIR"] || homeConfigDir(), ...parts);
}
/** A settings file under HYPERFRAMES_CONFIG_DIR starts as a copy of ~/.hyperframes' one, so an opt-out moves too. */
export function seededConfigFile(name: string): string {
const file = hyperframesConfigDir(name);
const home = join(homeConfigDir(), name);
if (file === home || existsSync(file) || !existsSync(home)) return file;
try {
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
copyFileSync(home, file, constants.COPYFILE_EXCL);
} catch {
// expected: an unreadable home folder, or another CLI seeded it first; the caller reads what is there
}
return file;
}
+6 -6
View File
@@ -1,7 +1,7 @@
import { randomUUID } from "node:crypto";
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import { join, resolve } from "node:path";
import { hyperframesConfigDir, seededConfigFile } from "./configDir.js";
interface ProjectLink {
projectId: string;
@@ -10,8 +10,8 @@ interface ProjectLink {
type ProjectLinks = Record<string, ProjectLink>;
const CONFIG_DIR = join(homedir(), ".hyperframes");
const PROJECTS_FILE = join(CONFIG_DIR, "projects.json");
const configDir = () => hyperframesConfigDir();
const projectsFile = () => seededConfigFile("projects.json");
/** Read + parse a JSON object file, or null if it's missing, unreadable, or not an object. */
function readJsonRecord(path: string): Record<string, unknown> | null {
@@ -34,7 +34,7 @@ function isProjectLink(value: unknown): value is ProjectLink {
}
function readProjectLinks(): ProjectLinks {
const record = readJsonRecord(PROJECTS_FILE);
const record = readJsonRecord(projectsFile());
if (!record) return {};
const links: ProjectLinks = {};
for (const [path, value] of Object.entries(record)) {
@@ -47,8 +47,8 @@ function readProjectLinks(): ProjectLinks {
function writeProjectLinks(links: ProjectLinks): void {
try {
mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
writeFileSync(PROJECTS_FILE, `${JSON.stringify(links, null, 2)}\n`, { mode: 0o600 });
mkdirSync(configDir(), { recursive: true, mode: 0o700 });
writeFileSync(projectsFile(), `${JSON.stringify(links, null, 2)}\n`, { mode: 0o600 });
} catch {
// Project links must never prevent local CLI commands from running.
}
+9 -1
View File
@@ -12,7 +12,7 @@ import {
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, expect, it } from "vitest";
import { RUNNING_STALE_MS, registerRunningCli } from "./runningCli.js";
import { RUNNING_STALE_MS, registerRunningCli, registeredAsRunning } from "./runningCli.js";
let dir = "";
afterEach(() => rmSync(dir, { recursive: true, force: true }));
@@ -81,3 +81,11 @@ it("removes the files of processes that are gone or stopped beating, and keeps l
process.off("exit", listener);
}
});
it("says when this process cannot be put on record, and never throws", () => {
dir = mkdtempSync(join(tmpdir(), "hf-running-"));
const notAFolder = join(dir, "file");
writeFileSync(notAFolder, "");
expect(registerRunningCli(join(notAFolder, "running"))).toBe(false);
expect(registeredAsRunning()).toBe(false);
});
+13 -6
View File
@@ -1,9 +1,9 @@
import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
import { hyperframesConfigDir } from "./configDir.js";
/** One empty file per live CLI process, named by pid; the background installer waits until none is alive. */
export const RUNNING_DIR = join(homedir(), ".hyperframes", "running");
export const runningDir = () => hyperframesConfigDir("running");
const RUNNING_HEARTBEAT_MS = 30_000;
export const RUNNING_STALE_MS = 10 * 60_000;
@@ -39,11 +39,16 @@ function pruneExitedClis(dir: string, own: string): void {
}
}
/** Mark this process as running until it exits. Never throws: a failed write only lets an update land sooner. */
let registered = false;
/** Whether this process is on record as running, so an installer would wait for it to exit. */
export const registeredAsRunning = (): boolean => registered;
/** Mark this process as running until it exits. Never throws: false when the record cannot be written. */
export function registerRunningCli(
dir: string = RUNNING_DIR,
dir: string = runningDir(),
heartbeatMs: number = RUNNING_HEARTBEAT_MS,
): void {
): boolean {
try {
mkdirSync(dir, { recursive: true, mode: 0o700 });
const file = join(dir, String(process.pid));
@@ -66,7 +71,9 @@ export function registerRunningCli(
/* already gone */
}
});
registered = true;
} catch {
/* best-effort */
registered = false;
}
return registered;
}
+1 -1
View File
@@ -18,7 +18,7 @@
"files": 13
},
"media-use": {
"hash": "40fbd6271fb7be28",
"hash": "f3e4cc75041371b3",
"files": 118
},
"remotion-to-hyperframes": {
+6 -1
View File
@@ -50,8 +50,13 @@ export function optedOut() {
}
// Read and write the shared config so media-use keeps one identity per install.
// Until the CLI seeds HYPERFRAMES_CONFIG_DIR's copy, ~/.hyperframes' own still holds the opt-out.
function sharedConfigPath() {
return join(homedir(), ".hyperframes", "config.json");
const home = join(homedir(), ".hyperframes", "config.json");
const dir = process.env.HYPERFRAMES_CONFIG_DIR;
if (!dir) return home;
const file = join(dir, "config.json");
return existsSync(file) || !existsSync(home) ? file : home;
}
function readSharedConfig() {
@@ -11,6 +11,7 @@ import { optedOut } from "./telemetry.mjs";
const ENV_KEYS = [
"HOME",
"USERPROFILE",
"HYPERFRAMES_CONFIG_DIR",
"HYPERFRAMES_NO_TELEMETRY",
"DO_NOT_TRACK",
"CI",
@@ -71,3 +72,27 @@ test("optedOut still honors the env opt-outs", () => {
delete process.env.DO_NOT_TRACK;
}
});
test("optedOut reads the shared config from HYPERFRAMES_CONFIG_DIR when it is set", () => {
writeConfig(null);
const configDir = join(home, "elsewhere");
mkdirSync(configDir, { recursive: true });
writeFileSync(join(configDir, "config.json"), JSON.stringify({ telemetryEnabled: false }));
process.env.HYPERFRAMES_CONFIG_DIR = configDir;
try {
assert.equal(optedOut(), true);
} finally {
delete process.env.HYPERFRAMES_CONFIG_DIR;
}
});
test("an opt-out in ~/.hyperframes holds until HYPERFRAMES_CONFIG_DIR has its own config", () => {
writeConfig(JSON.stringify({ telemetryEnabled: false }));
process.env.HYPERFRAMES_CONFIG_DIR = join(home, "moved");
try {
assert.equal(optedOut(), true);
} finally {
delete process.env.HYPERFRAMES_CONFIG_DIR;
writeConfig(null);
}
});