@hyperframes/studio 0.7.107 → 0.7.108

package/src/telemetry/system.ts

@@ -4,6 +4,8 @@
 // No PII — only environment characteristics useful for product analytics.
 // ---------------------------------------------------------------------------
 
+import { agentRuntimeProperty } from "./agentRuntime";
+
 export interface BrowserSystemMeta {
   user_agent: string;
   language: string;
@@ -13,6 +15,8 @@ export interface BrowserSystemMeta {
   timezone_offset_minutes: number;
   is_mobile: boolean;
   studio_version: string;
+  /** Which coding agent is driving this Studio, or null when a person is. */
+  agent_runtime: string;
 }
 
 const EMPTY_META: BrowserSystemMeta = {
@@ -24,6 +28,7 @@ const EMPTY_META: BrowserSystemMeta = {
   timezone_offset_minutes: 0,
   is_mobile: false,
   studio_version: "dev",
+  agent_runtime: "none",
 };
 
 let cached: BrowserSystemMeta | null = null;
@@ -46,6 +51,9 @@ export function getBrowserSystemMeta(): BrowserSystemMeta {
     timezone_offset_minutes: new Date().getTimezoneOffset(),
     is_mobile: /Android|iPhone|iPad/i.test(ua),
     studio_version: typeof __STUDIO_VERSION__ !== "undefined" ? __STUDIO_VERSION__ : "dev",
+    // Same value the `studio:*` transport attaches, from the same accessor —
+    // two families that disagreed here would split every agent breakdown.
+    agent_runtime: agentRuntimeProperty(),
   };
   return cached;
 }

package/src/utils/studioFileHistory.test.ts

@@ -29,6 +29,55 @@ describe("saveProjectFilesWithHistory", () => {
     });
   });
 
+  /**
+   * Deleting a clip POSTs `remove-element`, which rewrites the file server-side,
+   * and only then saves the duration shrink. Expecting the content read before
+   * the mutation made the server refuse that write as a conflict: the save queue
+   * paused on the 409 and the clip stayed on the timeline until a reload.
+   */
+  it("expects what is on disk, not the undo baseline, when they differ", async () => {
+    const expectations: Record<string, string | undefined> = {};
+    const recordEdit = vi.fn();
+
+    await saveProjectFilesWithHistory({
+      projectId: "project-1",
+      label: "Delete timeline clip",
+      kind: "timeline",
+      files: { "index.html": "removed+shrunk" },
+      readFile: async () => "original",
+      diskContent: { "index.html": "removed" },
+      writeFile: async (path, _content, expectedContent) => {
+        expectations[path] = expectedContent;
+      },
+      recordEdit,
+    });
+
+    expect(expectations["index.html"]).toBe("removed");
+    // Undo still goes all the way back, which is the whole reason the two are
+    // allowed to differ.
+    expect(recordEdit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        files: { "index.html": { before: "original", after: "removed+shrunk" } },
+      }),
+    );
+  });
+
+  it("still expects the undo baseline when nothing says otherwise", async () => {
+    const expectations: Record<string, string | undefined> = {};
+    await saveProjectFilesWithHistory({
+      projectId: "project-1",
+      label: "Move layer",
+      kind: "manual",
+      files: { "index.html": "after" },
+      readFile: async () => "before",
+      writeFile: async (path, _content, expectedContent) => {
+        expectations[path] = expectedContent;
+      },
+      recordEdit: vi.fn(),
+    });
+    expect(expectations["index.html"]).toBe("before");
+  });
+
   it("skips writes and history for unchanged content", async () => {
     const writeFile = vi.fn();
     const recordEdit = vi.fn();

package/src/utils/studioFileHistory.ts

@@ -34,6 +34,21 @@ interface SaveProjectFilesWithHistoryInput {
   readFile: (path: string) => Promise<string>;
   writeFile: ProjectFileWriter;
   recordEdit: (entry: RecordEditInput) => Promise<void>;
+  /**
+   * What a path holds ON DISK right now, when that is not the same as the
+   * history's "before".
+   *
+   * The two are normally one value, so the write's optimistic-concurrency
+   * expectation was taken straight from the undo baseline. They come apart when
+   * a server-side mutation has already written part of the edit: deleting a clip
+   * POSTs `remove-element`, which rewrites the file, and only then saves the
+   * duration shrink — expecting the pre-delete content it read at the start. The
+   * server had moved the file on, so the write was refused as a conflict, the
+   * save queue paused, and the clip stayed on the timeline until a reload.
+   *
+   * Undo still restores `before`; this only says what to expect on disk.
+   */
+  diskContent?: Record<string, string>;
 }
 
 export async function readProjectFileContent(pid: string, path: string): Promise<string> {
@@ -57,6 +72,7 @@ export async function saveProjectFilesWithHistory({
   readFile,
   writeFile,
   recordEdit,
+  diskContent,
 }: SaveProjectFilesWithHistoryInput): Promise<string[]> {
   return serializeStudioFileMutations(writeFile, Object.keys(files), async () => {
     const snapshots: Record<string, { before: string; after: string }> = {};
@@ -73,7 +89,7 @@ export async function saveProjectFilesWithHistory({
     const writtenPaths: string[] = [];
     try {
       for (const path of changedPaths) {
-        await writeFile(path, snapshots[path].after, snapshots[path].before);
+        await writeFile(path, snapshots[path].after, diskContent?.[path] ?? snapshots[path].before);
         writtenPaths.push(path);
       }
 

package/src/utils/studioTelemetry.ts

@@ -1,6 +1,7 @@
 import { resolveStudioDistinctId } from "../telemetry/distinctId";
 import { browserTelemetryAllowed } from "../telemetry/policy";
 import { canaryEventProperties } from "../telemetry/canary";
+import { agentRuntimeProperty } from "../telemetry/agentRuntime";
 
 // PostHog public ingest key — write-only, safe to ship in the client bundle
 const POSTHOG_API_KEY = "phc_zjjbX0PnWxERXrMHhkEJWj9A9BhGVLRReICgsfTMmpx";
@@ -42,6 +43,11 @@ function isEnabled(): boolean {
 function getSessionProperties(): EventProperties {
   return {
     studio_version: typeof __STUDIO_VERSION__ !== "undefined" ? __STUDIO_VERSION__ : "dev",
+    // On EVERY event, not just the audio ones. "Which of these sessions was a
+    // person and which was an agent" is a question worth asking of any feature,
+    // and a property that only some events carry cannot answer it — the
+    // breakdown silently reads as though the agent never used the rest.
+    agent_runtime: agentRuntimeProperty(),
     screen_width: window.screen?.width,
     screen_height: window.screen?.height,
     viewport_width: window.innerWidth,
@@ -73,9 +79,8 @@ export function trackStudioEvent(event: string, properties: EventProperties = {}
   }
 }
 
-async function flushEvents(): Promise<void> {
-  if (queue.length === 0) return;
-
+/** The queue, shaped for PostHog's batch endpoint — shared by both drain paths. */
+function drainBatch() {
   const batch = queue.map((e) => ({
     event: e.event,
     properties: { ...e.properties, $ip: null },
@@ -83,6 +88,13 @@ async function flushEvents(): Promise<void> {
     timestamp: e.timestamp,
   }));
   queue = [];
+  return batch;
+}
+
+async function flushEvents(): Promise<void> {
+  if (queue.length === 0) return;
+
+  const batch = drainBatch();
 
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
@@ -112,13 +124,7 @@ export function flushViaBeacon(): void {
     flushTimer = null;
   }
   if (queue.length === 0) return;
-  const batch = queue.map((e) => ({
-    event: e.event,
-    properties: { ...e.properties, $ip: null },
-    distinct_id: getDistinctId(),
-    timestamp: e.timestamp,
-  }));
-  queue = [];
+  const batch = drainBatch();
   const body = JSON.stringify({ api_key: POSTHOG_API_KEY, batch });
   try {
     navigator.sendBeacon(`${POSTHOG_HOST}/batch/`, body);