mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-18 16:08:56 +00:00
* feat(cli): share rendered videos through unified reviews (#7135) * feat(share): attach editable project sources to reviews (#7137) * feat(share): measure local sharing outcomes (#7138) * feat(cli): stage the sixty-day publish transition (#7136) * feat(studio): share review pages from local preview (#7140) Advertise the CLI sharing bridge before bootstrapping it so standalone Studio does not request unsupported routes. Preserve origin and session checks. Budget the intended sharing artifact: clean main packs at 8,060,519 bytes versus 8,162,979 with sharing (8,169,168 in CI). Required policy and Unicode tables, bundled sharing code, and Studio controls account for the growth. Set the packed-only budget to 8,577,627, following the 5% headroom convention; retain the unpacked cap and all package checks. * fix(share): persist refusals and improve CLI retry feedback * fix(ci): restore render diagnostics and include sharing workspace * fix(cli): keep sharing owner error codes stable * fix(share): clarify update feedback and align audience changes * fix(share): clarify updates and avoid scratch-file rerenders * fix(cli): report active shares and preserve update channels * fix(cli): resolve update channel when checking registry * fix(ci): refresh sharing package budgets after rebase * fix(share): require consent before uploading project files
411 lines
16 KiB
JavaScript
411 lines
16 KiB
JavaScript
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { mkdtemp, writeFile, rm, readFile, symlink, mkdir, realpath } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { dirname, join } from "node:path";
|
|
import { createHash } from "node:crypto";
|
|
import {
|
|
shareSources,
|
|
shareSourceFingerprint,
|
|
createProjectShareSourceStore,
|
|
} from "../src/shareSources.mjs";
|
|
import { projectFingerprint } from "../src/projectSnapshot.mjs";
|
|
import { captureProject } from "../src/sources/capture.mjs";
|
|
import { sourceApi } from "../src/sources/api.mjs";
|
|
import { SyncApiError } from "../src/sources/errors.mjs";
|
|
import { V1_LIMITS } from "../src/sources/limits.mjs";
|
|
import { bindShareHost } from "../src/host.mjs";
|
|
|
|
bindShareHost({ reviewUploadOrigins: ["https://storage.test"] });
|
|
|
|
const signed = {
|
|
token: "test-token",
|
|
owner: "owner",
|
|
heygen: "https://app.test",
|
|
heygenApi: "https://api.test",
|
|
};
|
|
async function fixture(t, files = {}) {
|
|
const root = await realpath(await mkdtemp(join(tmpdir(), "hf-source-test-")));
|
|
t.after(() => rm(root, { recursive: true, force: true }));
|
|
await writeFile(join(root, "index.html"), "<html>video</html>");
|
|
for (const [file, content] of Object.entries(files)) await writeFile(join(root, file), content);
|
|
const rendered = await projectFingerprint(root);
|
|
const store = createProjectShareSourceStore();
|
|
return {
|
|
root,
|
|
rendered,
|
|
store,
|
|
key: { backend: signed.heygenApi, account: signed.owner, projectPath: root },
|
|
};
|
|
}
|
|
function fakeServer(overrides = {}) {
|
|
const calls = { create: 0, begin: [], puts: [], submit: 0, snapshot: 0 };
|
|
let held;
|
|
let composition;
|
|
const receipt = (status = "pending") => ({
|
|
uploadId: "upload",
|
|
compositionId: composition,
|
|
snapshotId: "snapshot",
|
|
status,
|
|
errorCode: null,
|
|
baseSnapshotId: null,
|
|
resolvesConflictSnapshotIds: [],
|
|
manifestSha256: held.manifest.sha256,
|
|
uploadDeadline: "2099-01-01T00:00:00Z",
|
|
verificationDeadline: null,
|
|
completedAt: null,
|
|
result:
|
|
status === "completed"
|
|
? {
|
|
snapshotId: "snapshot",
|
|
publicationOutcome: "published",
|
|
conflictedWithSnapshotId: null,
|
|
}
|
|
: null,
|
|
});
|
|
const api = {
|
|
limits: async () => ({
|
|
at: "read",
|
|
syncAllowed: true,
|
|
maxCompositions: 5,
|
|
compositions: 0,
|
|
push: V1_LIMITS,
|
|
}),
|
|
create: async (_space, id) => {
|
|
calls.create++;
|
|
composition = id;
|
|
return { id };
|
|
},
|
|
begin: async (_space, id, request) => {
|
|
composition = id;
|
|
held = request;
|
|
calls.begin.push(request);
|
|
return { ...receipt(), created: true, present: [], needed: request.manifest.document.files };
|
|
},
|
|
uploadUrls: async (_space, _comp, _upload, files) =>
|
|
files.map((file) => ({
|
|
...file,
|
|
url: `https://storage.test/${file.sha256}`,
|
|
headers: {},
|
|
expiresAt: "2099-01-01T00:00:00Z",
|
|
parts: [],
|
|
})),
|
|
submit: async () => {
|
|
calls.submit++;
|
|
return receipt("completed");
|
|
},
|
|
status: async () => receipt("completed"),
|
|
snapshot: async (_space, id, snapshot) => {
|
|
calls.snapshot++;
|
|
return {
|
|
id: snapshot,
|
|
compositionId: id,
|
|
manifestSha256: held.manifest.sha256,
|
|
manifest: held.manifest,
|
|
publicationOutcome: "published",
|
|
};
|
|
},
|
|
...overrides,
|
|
};
|
|
const fetchImpl = async (url, init) => {
|
|
assert.equal(init.headers.authorization, undefined);
|
|
const bytes = Buffer.from(await new Response(init.body).arrayBuffer());
|
|
assert.equal(createHash("sha256").update(bytes).digest("hex"), url.split("/").at(-1));
|
|
calls.puts.push(bytes);
|
|
return new Response(null, { status: 200 });
|
|
};
|
|
return { api, calls, fetchImpl, receipt };
|
|
}
|
|
|
|
for (const path of [".media/voice.mp3", ".hyperframes/studio-manual-edits.json"]) {
|
|
test(`changing ${path} refuses source preparation and final attachment to the old render`, async (t) => {
|
|
const f = await fixture(t);
|
|
await writeFile(join(f.root, "index.html"), '<audio src=".media/voice.mp3"></audio>');
|
|
await mkdir(dirname(join(f.root, path)), { recursive: true });
|
|
await writeFile(join(f.root, path), "original");
|
|
const rendered = await projectFingerprint(f.root);
|
|
const content = await shareSourceFingerprint(f.root);
|
|
const server = fakeServer();
|
|
const source = shareSources({
|
|
access: async () => signed,
|
|
spaceId: "personal",
|
|
...server,
|
|
fingerprint: async (root) =>
|
|
content === (await shareSourceFingerprint(root)) ? projectFingerprint(root) : null,
|
|
});
|
|
await writeFile(join(f.root, path), "changed");
|
|
assert.equal(await projectFingerprint(f.root), rendered);
|
|
assert.equal((await source.prepare(f.root, rendered)).reason, "source_render_changed");
|
|
assert.equal(server.calls.begin.length, 0);
|
|
assert.equal(await source.filesForExport(f.root, rendered), null);
|
|
await writeFile(join(f.root, path), "original");
|
|
assert.equal((await source.prepare(f.root, rendered)).at, "ready");
|
|
assert.ok(await source.filesForExport(f.root, rendered));
|
|
await writeFile(join(f.root, path), "changed after preparation");
|
|
assert.equal(await source.filesForExport(f.root, rendered), null);
|
|
});
|
|
}
|
|
|
|
test("source upload verifies before attachment and a fresh adapter reuses the exact published snapshot", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const options = { access: async () => signed, spaceId: "personal", ...server };
|
|
const source = shareSources(options);
|
|
assert.equal(await source.filesForExport(f.root, f.rendered), null);
|
|
const result = await source.prepare(f.root, f.rendered);
|
|
assert.equal(result.at, "ready");
|
|
assert.equal(server.calls.puts.length, 1);
|
|
assert.equal(server.calls.submit, 1);
|
|
assert.deepEqual(await source.filesForExport(f.root, f.rendered), result.snapshot);
|
|
assert.equal((await shareSources(options).prepare(f.root, f.rendered)).at, "ready");
|
|
assert.equal(server.calls.begin.length, 1);
|
|
assert.equal(server.calls.snapshot, 1);
|
|
const binding = await f.store.read(f.key);
|
|
assert.equal(binding.inflight, null);
|
|
assert.equal(binding.base.snapshotId, "snapshot");
|
|
});
|
|
|
|
test("changed assets invalidate prepared source even when the HTML render fingerprint stays unchanged", async (t) => {
|
|
const f = await fixture(t, { "media.mp4": "first" });
|
|
const source = shareSources({
|
|
access: async () => signed,
|
|
spaceId: "personal",
|
|
...fakeServer(),
|
|
fingerprint: async () => f.rendered,
|
|
});
|
|
assert.equal((await source.prepare(f.root, f.rendered)).at, "ready");
|
|
await writeFile(join(f.root, "media.mp4"), "other");
|
|
assert.equal(await source.filesForExport(f.root, f.rendered), null);
|
|
});
|
|
|
|
test("eligibility and busy edits refuse before creating cloud compositions", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer({ limits: async () => ({ syncAllowed: false }) });
|
|
assert.deepEqual(
|
|
await shareSources({ access: async () => signed, spaceId: "personal", ...server }).prepare(
|
|
f.root,
|
|
f.rendered,
|
|
),
|
|
{ at: "unavailable", reason: "source_plan_required" },
|
|
);
|
|
assert.equal(server.calls.create, 0);
|
|
await mkdir(join(f.root, ".hyperframes"), { recursive: true });
|
|
await writeFile(join(f.root, ".hyperframes/history-turn.json"), "{}");
|
|
const next = fakeServer();
|
|
assert.equal(
|
|
(
|
|
await shareSources({ access: async () => signed, spaceId: "personal", ...next }).prepare(
|
|
f.root,
|
|
f.rendered,
|
|
)
|
|
).reason,
|
|
"source_edit_in_progress",
|
|
);
|
|
assert.equal(next.calls.create, 0);
|
|
});
|
|
|
|
test("lost Begin response retries the durable idempotency key, without creating a second composition", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const begin = server.api.begin;
|
|
let fail = true;
|
|
server.api.begin = async (...args) => {
|
|
const answer = await begin(...args);
|
|
if (fail) {
|
|
fail = false;
|
|
throw new Error("network lost");
|
|
}
|
|
return answer;
|
|
};
|
|
const opts = { access: async () => signed, spaceId: "personal", ...server };
|
|
await assert.rejects(shareSources(opts).prepare(f.root, f.rendered), /network lost/);
|
|
assert.equal((await shareSources(opts).prepare(f.root, f.rendered)).at, "ready");
|
|
assert.equal(server.calls.begin[0].idempotencyKey, server.calls.begin[1].idempotencyKey);
|
|
assert.deepEqual(server.calls.begin[0].manifest, server.calls.begin[1].manifest);
|
|
});
|
|
|
|
test("confirmed expired upload clears its intent so a retry starts with a new key", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const begin = server.api.begin;
|
|
server.api.begin = async (...args) => {
|
|
const answer = await begin(...args);
|
|
return server.calls.begin.length === 1 ? { ...answer, status: "expired" } : answer;
|
|
};
|
|
const source = shareSources({ access: async () => signed, spaceId: "personal", ...server });
|
|
|
|
assert.equal((await source.prepare(f.root, f.rendered)).reason, "source_upload_expired");
|
|
assert.equal((await f.store.read(f.key)).inflight, null);
|
|
assert.equal((await source.prepare(f.root, f.rendered)).at, "ready");
|
|
assert.notEqual(server.calls.begin[0].idempotencyKey, server.calls.begin[1].idempotencyKey);
|
|
});
|
|
|
|
test("an unwritable pending upload is cancelled so unchanged files can retry with a new key", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const grants = server.api.uploadUrls;
|
|
server.api.uploadUrls = async () => {
|
|
throw new SyncApiError("file-not-writable");
|
|
};
|
|
server.api.status = async () => server.receipt("pending");
|
|
let cancelled = 0;
|
|
server.api.cancel = async () => {
|
|
cancelled++;
|
|
return { ...server.receipt("failed"), errorCode: "cancelled" };
|
|
};
|
|
const source = shareSources({ access: async () => signed, spaceId: "personal", ...server });
|
|
assert.equal((await source.prepare(f.root, f.rendered)).reason, "source_upload_not_writable");
|
|
assert.equal(cancelled, 1);
|
|
assert.equal((await f.store.read(f.key)).inflight, null);
|
|
server.api.uploadUrls = grants;
|
|
assert.equal((await source.prepare(f.root, f.rendered)).at, "ready");
|
|
assert.notEqual(server.calls.begin[0].idempotencyKey, server.calls.begin[1].idempotencyKey);
|
|
});
|
|
|
|
for (const status of ["verifying", "completed"]) {
|
|
test(`unwritable recovery retains an upload that raced cancellation into ${status}`, async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
server.api.uploadUrls = async () => {
|
|
throw new SyncApiError("file-not-writable");
|
|
};
|
|
let reads = 0;
|
|
server.api.status = async () => {
|
|
const receipt = server.receipt(++reads === 1 ? "pending" : status);
|
|
if (receipt.result) receipt.result.publicationOutcome = "conflict_saved";
|
|
return receipt;
|
|
};
|
|
server.api.cancel = async () => {
|
|
throw new SyncApiError("upload-not-pending");
|
|
};
|
|
const source = shareSources({ access: async () => signed, spaceId: "personal", ...server });
|
|
assert.equal(
|
|
(await source.prepare(f.root, f.rendered)).reason,
|
|
status === "verifying" ? "source_verification_pending" : "source_conflict",
|
|
);
|
|
assert.equal((await f.store.read(f.key)).inflight.uploadId, "upload");
|
|
assert.equal(server.calls.begin.length, 1);
|
|
});
|
|
}
|
|
|
|
test("changed source cancels the previous pending upload before using a new key", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const submit = server.api.submit;
|
|
server.api.submit = async () => {
|
|
throw new Error("lost connection");
|
|
};
|
|
server.api.status = async () => server.receipt("pending");
|
|
let cancelled = 0;
|
|
server.api.cancel = async () => {
|
|
cancelled++;
|
|
return { ...server.receipt("failed"), errorCode: "cancelled" };
|
|
};
|
|
const source = shareSources({ access: async () => signed, spaceId: "personal", ...server });
|
|
|
|
await assert.rejects(source.prepare(f.root, f.rendered), /lost connection/);
|
|
await writeFile(join(f.root, "index.html"), "<html>updated</html>");
|
|
server.api.submit = submit;
|
|
assert.equal((await source.prepare(f.root, await projectFingerprint(f.root))).at, "ready");
|
|
assert.equal(cancelled, 1);
|
|
assert.notEqual(server.calls.begin[0].idempotencyKey, server.calls.begin[1].idempotencyKey);
|
|
});
|
|
|
|
test("conflict and pending verification cannot be attached and keep recovery intent", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
server.api.submit = async () => ({
|
|
...server.receipt("completed"),
|
|
result: { snapshotId: "snapshot", publicationOutcome: "conflict_saved" },
|
|
});
|
|
const source = shareSources({ access: async () => signed, spaceId: "personal", ...server });
|
|
assert.equal((await source.prepare(f.root, f.rendered)).reason, "source_conflict");
|
|
assert.equal(await source.filesForExport(f.root, f.rendered), null);
|
|
assert.ok((await f.store.read(f.key)).inflight);
|
|
server.api.submit = async () => server.receipt("verifying");
|
|
const pending = shareSources({
|
|
access: async () => signed,
|
|
spaceId: "personal",
|
|
...server,
|
|
verificationTimeoutMs: 0,
|
|
});
|
|
assert.equal((await pending.prepare(f.root, f.rendered)).reason, "source_verification_pending");
|
|
});
|
|
|
|
test("Desktop-owned source is read-only and never re-shared into a different workspace", async (t) => {
|
|
const f = await fixture(t);
|
|
const server = fakeServer();
|
|
const capture = await captureProject(f.root);
|
|
const binding = {
|
|
...f.key,
|
|
version: 1,
|
|
compositionId: "desktop",
|
|
ownerSpaceId: "team",
|
|
base: { manifestSha256: capture.manifest.sha256, snapshotId: "desktop-snapshot" },
|
|
inflight: null,
|
|
};
|
|
const opts = {
|
|
access: async () => signed,
|
|
spaceId: "personal",
|
|
existingBinding: async () => binding,
|
|
...server,
|
|
};
|
|
assert.equal(
|
|
(await shareSources(opts).prepare(f.root, f.rendered)).reason,
|
|
"source_other_workspace",
|
|
);
|
|
binding.ownerSpaceId = "personal";
|
|
binding.sharedFrom = { reviewProjectId: "someone-elses-share" };
|
|
assert.equal(
|
|
(await shareSources(opts).prepare(f.root, f.rendered)).reason,
|
|
"source_owned_by_someone_else",
|
|
);
|
|
assert.equal(server.calls.create, 0);
|
|
});
|
|
|
|
test("binding reads reject copied folders, account changes, and symlink state files", async (t) => {
|
|
const f = await fixture(t);
|
|
await shareSources({ access: async () => signed, spaceId: "personal", ...fakeServer() }).prepare(
|
|
f.root,
|
|
f.rendered,
|
|
);
|
|
await assert.rejects(f.store.read({ ...f.key, account: "other" }), /another account/);
|
|
const g = await fixture(t);
|
|
const hash = createHash("sha256").update(signed.heygenApi).digest("hex").slice(0, 16);
|
|
const name = `.hyperframes/share-sync.${hash}.json`;
|
|
await mkdir(join(g.root, ".hyperframes"));
|
|
await writeFile(join(g.root, name), await readFile(join(f.root, name)));
|
|
await assert.rejects(g.store.read(g.key), /another account/);
|
|
await rm(join(g.root, name));
|
|
await symlink(join(f.root, name), join(g.root, name));
|
|
await assert.rejects(g.store.read(g.key));
|
|
});
|
|
|
|
test("HTTP adapter identifies CLI and sends credentials only to the API host", async () => {
|
|
const requests = [];
|
|
const api = sourceApi({
|
|
access: async () => signed,
|
|
fetchImpl: async (url, init) => {
|
|
requests.push({ url, init });
|
|
return Response.json({
|
|
data: {
|
|
upload_id: "up",
|
|
composition_id: "comp",
|
|
snapshot_id: "snap",
|
|
status: "pending",
|
|
manifest_sha256: "hash",
|
|
upload_deadline: "2099-01-01T00:00:00Z",
|
|
},
|
|
});
|
|
},
|
|
});
|
|
await api.begin("space", "comp", {
|
|
idempotencyKey: "key",
|
|
baseSnapshotId: null,
|
|
manifest: { sha256: "hash", document: {} },
|
|
});
|
|
assert.equal(JSON.parse(requests[0].init.body).client_type, "cli");
|
|
assert.equal(requests[0].init.headers.authorization, "Bearer test-token");
|
|
assert.match(requests[0].url, /^https:\/\/api.test\/v3\//);
|
|
});
|