@agent-native/core 0.114.6 → 0.114.7

package/corpus/templates/clips/actions/apply-rewind-extension.ts

@@ -0,0 +1,195 @@
+import { defineAction } from "@agent-native/core";
+import {
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { isPrivateClip } from "../app/lib/rewind-visibility.js";
+import { parseEdits, serializeEdits } from "../app/lib/timestamp-mapping.js";
+import { getDb, schema } from "../server/db/index.js";
+import {
+  getCurrentOwnerEmail,
+  ownerEmailMatches,
+} from "../server/lib/recordings.js";
+import { parseTranscriptSegments } from "../shared/transcript-segments.js";
+import { assertNoDirectRecordingShares } from "./make-recording-private-for-rewind.js";
+import {
+  rewindExtensionKey,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+function shiftedJsonArray(
+  raw: string | null | undefined,
+  addedMs: number,
+  fields: string[],
+): string {
+  try {
+    const parsed = JSON.parse(raw || "[]");
+    if (!Array.isArray(parsed)) return raw || "[]";
+    return JSON.stringify(
+      parsed.map((item) => {
+        if (!item || typeof item !== "object") return item;
+        const next = { ...item } as Record<string, unknown>;
+        for (const field of fields) {
+          if (typeof next[field] === "number") {
+            next[field] = Math.max(0, Math.round(next[field] + addedMs));
+          }
+        }
+        return next;
+      }),
+    );
+  } catch {
+    return raw || "[]";
+  }
+}
+
+export default defineAction({
+  description:
+    "Replace an owned Clip with an explicitly prepended local Rewind range while shifting its timestamped editor data and preserving the original-start marker.",
+  schema: z.object({
+    recordingId: z.string(),
+    requestId: z.string(),
+    preRollRecordingId: z.string(),
+    videoUrl: z.string().min(1),
+    durationMs: z.number().int().positive(),
+    addedMs: z
+      .number()
+      .int()
+      .positive()
+      .max(5 * 60_000),
+  }),
+  run: async (args) => {
+    if (args.videoUrl.startsWith("data:")) {
+      throw new Error(
+        "The combined Clip must be uploaded before it is applied.",
+      );
+    }
+    const db = getDb();
+    const ownerEmail = getCurrentOwnerEmail();
+    const [recording] = await db
+      .select()
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, args.recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    const [preRoll] = await db
+      .select()
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, args.preRollRecordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    if (!recording || !preRoll) {
+      throw new Error("The Clip or its local Rewind pre-roll is unavailable.");
+    }
+    if (
+      !isPrivateClip(recording.visibility) ||
+      !isPrivateClip(preRoll.visibility)
+    ) {
+      throw new Error(
+        "Rewind history can only be added to a private Clip from a private pre-roll.",
+      );
+    }
+    await assertNoDirectRecordingShares(args.recordingId);
+    const key = rewindExtensionKey(args.recordingId);
+    const request = (await readAppState(key)) as RewindExtensionRequest | null;
+    if (
+      !request ||
+      request.requestId !== args.requestId ||
+      request.status !== "ready" ||
+      request.preRollRecordingId !== args.preRollRecordingId
+    ) {
+      throw new Error("The Rewind pre-roll request is not ready to apply.");
+    }
+    const expectedDuration = recording.durationMs + args.addedMs;
+    if (Math.abs(args.durationMs - expectedDuration) > 2_000) {
+      throw new Error("The combined Clip duration does not match its sources.");
+    }
+
+    const edits = parseEdits(recording.editsJson);
+    edits.trims = edits.trims.map((trim) => ({
+      ...trim,
+      startMs: trim.startMs + args.addedMs,
+      endMs: trim.endMs + args.addedMs,
+    }));
+    edits.blurs = edits.blurs.map((blur) => ({
+      ...blur,
+      startMs: blur.startMs + args.addedMs,
+      endMs: blur.endMs + args.addedMs,
+    }));
+    edits.rewindOriginalStartMs = args.addedMs;
+
+    const [transcript] = await db
+      .select()
+      .from(schema.recordingTranscripts)
+      .where(eq(schema.recordingTranscripts.recordingId, args.recordingId));
+    const shiftedTranscript = transcript
+      ? JSON.stringify(
+          parseTranscriptSegments(transcript.segmentsJson).map((segment) => ({
+            ...segment,
+            startMs: segment.startMs + args.addedMs,
+            endMs: segment.endMs + args.addedMs,
+          })),
+        )
+      : null;
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.recordings)
+        .set({
+          videoUrl: args.videoUrl,
+          videoFormat: "mp4",
+          durationMs: args.durationMs,
+          editsJson: serializeEdits(edits),
+          chaptersJson: shiftedJsonArray(recording.chaptersJson, args.addedMs, [
+            "startMs",
+          ]),
+          thumbnailUrl: null,
+          animatedThumbnailUrl: null,
+          updatedAt: now,
+        })
+        .where(eq(schema.recordings.id, args.recordingId));
+      if (transcript && shiftedTranscript) {
+        await tx
+          .update(schema.recordingTranscripts)
+          .set({ segmentsJson: shiftedTranscript, updatedAt: now })
+          .where(eq(schema.recordingTranscripts.recordingId, args.recordingId));
+      }
+      await tx
+        .update(schema.recordingComments)
+        .set({
+          videoTimestampMs: sql`${schema.recordingComments.videoTimestampMs} + ${args.addedMs}`,
+          updatedAt: now,
+        })
+        .where(eq(schema.recordingComments.recordingId, args.recordingId));
+      await tx
+        .update(schema.recordingReactions)
+        .set({
+          videoTimestampMs: sql`${schema.recordingReactions.videoTimestampMs} + ${args.addedMs}`,
+        })
+        .where(eq(schema.recordingReactions.recordingId, args.recordingId));
+      await tx
+        .update(schema.recordings)
+        .set({ trashedAt: now, expiresAt: now, updatedAt: now })
+        .where(eq(schema.recordings.id, args.preRollRecordingId));
+    });
+
+    const applied: RewindExtensionRequest = {
+      ...request,
+      status: "applied",
+      actualDurationMs: args.addedMs,
+      updatedAt: now,
+    };
+    await writeAppState(key, applied);
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return { recordingId: args.recordingId, request: applied };
+  },
+});

package/corpus/templates/clips/actions/delete-agent-recording-if-unpromoted.ts

@@ -0,0 +1,64 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import deleteRecordingPermanent from "./delete-recording-permanent.js";
+
+export default defineAction({
+  description:
+    "Delete an expired agent-created Clip only if it is still private and has not been renamed, shared, commented on, reacted to, tagged, archived, or trashed.",
+  schema: z.object({ id: z.string() }),
+  run: async ({ id }) => {
+    await assertAccess("recording", id, "editor");
+    const db = getDb();
+    const [recording] = await db
+      .select()
+      .from(schema.recordings)
+      .where(eq(schema.recordings.id, id));
+    if (!recording) return { id, deleted: true, reason: "already-missing" };
+
+    const [share, comment, reaction, tag] = await Promise.all([
+      db
+        .select({ id: schema.recordingShares.id })
+        .from(schema.recordingShares)
+        .where(eq(schema.recordingShares.resourceId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingComments.id })
+        .from(schema.recordingComments)
+        .where(eq(schema.recordingComments.recordingId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingReactions.id })
+        .from(schema.recordingReactions)
+        .where(eq(schema.recordingReactions.recordingId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingTags.id })
+        .from(schema.recordingTags)
+        .where(eq(schema.recordingTags.recordingId, id))
+        .limit(1),
+    ]);
+
+    const promoted =
+      recording.visibility !== "private" ||
+      recording.titleSource === "manual" ||
+      Boolean(recording.archivedAt || recording.trashedAt) ||
+      share.length > 0 ||
+      comment.length > 0 ||
+      reaction.length > 0 ||
+      tag.length > 0;
+    if (promoted) {
+      await db
+        .update(schema.recordings)
+        .set({ expiresAt: null, updatedAt: new Date().toISOString() })
+        .where(eq(schema.recordings.id, id));
+      return { id, deleted: false, reason: "promoted" };
+    }
+
+    await deleteRecordingPermanent.run({ id });
+    return { id, deleted: true, reason: "retention-expired" };
+  },
+});

package/corpus/templates/clips/actions/get-rewind-extension-request.ts

@@ -0,0 +1,22 @@
+import { defineAction } from "@agent-native/core";
+import { readAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  rewindExtensionKey,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+export default defineAction({
+  description: "Read the current explicit Rewind pre-roll request for a Clip.",
+  schema: z.object({ recordingId: z.string() }),
+  http: { method: "GET" },
+  run: async ({ recordingId }) => {
+    await assertAccess("recording", recordingId, "owner");
+    const request = (await readAppState(
+      rewindExtensionKey(recordingId),
+    )) as RewindExtensionRequest | null;
+    return { request };
+  },
+});

package/corpus/templates/clips/actions/get-screen-memory-status.ts

@@ -4,9 +4,25 @@ import { z } from "zod";
 
 export default defineAction({
   description:
-    "Check local Clips Screen Memory status for this machine: enabled/paused state, local storage files, and capture recency. Screen Memory is disabled by default and local-only.",
+    "Check local Clips Screen Memory status for this machine: enabled/paused state, local metadata files, and capture recency. Screen Memory is disabled by default, local-only, and does not expose media bytes or images.",
   schema: z.object({}),
   http: { method: "GET" },
   readOnly: true,
-  run: async () => readScreenMemoryStatus(),
+  run: async () => {
+    const status = await readScreenMemoryStatus();
+    return {
+      feature: status.feature,
+      localOnly: status.localOnly,
+      enabled: status.enabled,
+      paused: status.paused,
+      state: status.state,
+      captureMode: status.config.captureMode,
+      retentionHours: status.config.retentionHours,
+      captureCount: status.captureCount,
+      storageBytes: status.storageBytes,
+      oldestCaptureAt: status.oldestCaptureAt,
+      newestCaptureAt: status.newestCaptureAt,
+      note: status.note,
+    };
+  },
 });

package/corpus/templates/clips/actions/list-rewind-extension-requests.ts

@@ -0,0 +1,52 @@
+import { defineAction } from "@agent-native/core";
+import { listAppState } from "@agent-native/core/application-state";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  getCurrentOwnerEmail,
+  ownerEmailMatches,
+} from "../server/lib/recordings.js";
+import {
+  REWIND_EXTENSION_PREFIX,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+export default defineAction({
+  description:
+    "List pending local Rewind pre-roll requests for the signed-in Clips Alpha app.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  run: async () => {
+    const entries = await listAppState(REWIND_EXTENSION_PREFIX);
+    const staleProcessingCutoff = Date.now() - 2 * 60_000;
+    const requests = entries
+      .map((entry) => entry.value as unknown as RewindExtensionRequest)
+      .filter(
+        (request) =>
+          request &&
+          typeof request.recordingId === "string" &&
+          (request.status === "pending" ||
+            (request.status === "processing" &&
+              Date.parse(request.updatedAt) < staleProcessingCutoff)),
+      );
+    if (!requests.length) return { requests: [] };
+    const ids = [...new Set(requests.map((request) => request.recordingId))];
+    const ownerEmail = getCurrentOwnerEmail();
+    const accessible = await getDb()
+      .select({ id: schema.recordings.id })
+      .from(schema.recordings)
+      .where(
+        and(
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          inArray(schema.recordings.id, ids),
+          eq(schema.recordings.status, "ready"),
+        ),
+      );
+    const allowed = new Set(accessible.map((row) => row.id));
+    return {
+      requests: requests.filter((request) => allowed.has(request.recordingId)),
+    };
+  },
+});

package/corpus/templates/clips/actions/make-recording-private-for-rewind.ts

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, notExists } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const DIRECT_SHARE_REWIND_ERROR =
+  "This Clip is still shared directly with other people. Remove their access in Share before adding local Rewind history.";
+
+export async function assertNoDirectRecordingShares(
+  recordingId: string,
+): Promise<void> {
+  const [share] = await getDb()
+    .select({ id: schema.recordingShares.id })
+    .from(schema.recordingShares)
+    .where(eq(schema.recordingShares.resourceId, recordingId))
+    .limit(1);
+  if (share) throw new Error(DIRECT_SHARE_REWIND_ERROR);
+}
+
+export default defineAction({
+  description:
+    "Make an owned recording private for a Rewind extension, refusing to continue while anyone still has direct access.",
+  schema: z.object({ recordingId: z.string() }),
+  run: async ({ recordingId }) => {
+    await assertAccess("recording", recordingId, "owner");
+
+    const now = new Date().toISOString();
+    const db = getDb();
+    const [recording] = await db
+      .update(schema.recordings)
+      .set({ visibility: "private", updatedAt: now })
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          notExists(
+            db
+              .select({ id: schema.recordingShares.id })
+              .from(schema.recordingShares)
+              .where(eq(schema.recordingShares.resourceId, recordingId)),
+          ),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+    if (!recording) {
+      // The conditional UPDATE is the invariant. This follow-up read only
+      // chooses the useful error message after the atomic mutation declined.
+      await assertNoDirectRecordingShares(recordingId);
+      throw new Error("This Clip is unavailable.");
+    }
+
+    return { recordingId, visibility: "private" as const };
+  },
+});

package/corpus/templates/clips/actions/query-screen-memory-context.ts

@@ -1,10 +1,10 @@
 import { defineAction } from "@agent-native/core";
-import { queryScreenMemoryContext } from "@agent-native/core/mcp-client";
+import { queryScreenMemoryForAgent } from "@agent-native/core/mcp-client";
 import { z } from "zod";
 
 export default defineAction({
   description:
-    "Search recent local Clips Screen Memory context from this machine. Returns bounded OCR/context snippets only; use get-screen-memory-status first if availability is unclear.",
+    "Search bounded local Clips Screen Memory evidence from this machine. Returns typed app-context, OCR, or transcript excerpts only when present in local files, plus coverage, gaps, segment references, jump targets, and truncation; never media bytes or images. Use get-screen-memory-status first if availability is unclear.",
   schema: z.object({
     query: z
       .string()
@@ -21,9 +21,9 @@ export default defineAction({
       .min(1)
       .max(50)
       .default(10)
-      .describe("Maximum number of context snippets to return"),
+      .describe("Maximum number of bounded local evidence items to return"),
   }),
   http: { method: "GET" },
   readOnly: true,
-  run: async (args) => queryScreenMemoryContext(args),
+  run: async (args) => queryScreenMemoryForAgent(args),
 });

package/corpus/templates/clips/actions/request-rewind-extension.ts

@@ -0,0 +1,81 @@
+import { defineAction } from "@agent-native/core";
+import {
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { isPrivateClip } from "../app/lib/rewind-visibility.js";
+import { getDb, schema } from "../server/db/index.js";
+import { nanoid } from "../server/lib/recordings.js";
+import { assertNoDirectRecordingShares } from "./make-recording-private-for-rewind.js";
+
+export const REWIND_EXTENSION_PREFIX = "rewind-extension-request-";
+
+export interface RewindExtensionRequest {
+  [key: string]: unknown;
+  requestId: string;
+  recordingId: string;
+  seconds: 30 | 300;
+  status:
+    | "pending"
+    | "processing"
+    | "ready"
+    | "applying"
+    | "applied"
+    | "failed";
+  requestedAt: string;
+  updatedAt: string;
+  preRollRecordingId?: string;
+  actualDurationMs?: number;
+  error?: string;
+}
+
+export function rewindExtensionKey(recordingId: string): string {
+  return `${REWIND_EXTENSION_PREFIX}${recordingId}`;
+}
+
+export default defineAction({
+  description:
+    "Ask the signed-in Clips Alpha app to retrieve an explicit 30-second or five-minute pre-roll from local Rewind for one owned recording.",
+  schema: z.object({
+    recordingId: z.string(),
+    seconds: z.union([z.literal(30), z.literal(300)]),
+  }),
+  run: async ({ recordingId, seconds }) => {
+    await assertAccess("recording", recordingId, "owner");
+    const [recording] = await getDb()
+      .select({ visibility: schema.recordings.visibility })
+      .from(schema.recordings)
+      .where(eq(schema.recordings.id, recordingId));
+    if (!recording || !isPrivateClip(recording.visibility)) {
+      throw new Error(
+        "Make this Clip private before adding local Rewind history.",
+      );
+    }
+    await assertNoDirectRecordingShares(recordingId);
+    const key = rewindExtensionKey(recordingId);
+    const existing = (await readAppState(key)) as RewindExtensionRequest | null;
+    if (existing && !["failed", "applied"].includes(existing.status)) {
+      return existing;
+    }
+    if (existing?.status === "applied") {
+      throw new Error(
+        "This Clip already includes an explicit Rewind pre-roll.",
+      );
+    }
+    const now = new Date().toISOString();
+    const request: RewindExtensionRequest = {
+      requestId: `rewind-extend-${nanoid()}`,
+      recordingId,
+      seconds,
+      status: "pending",
+      requestedAt: now,
+      updatedAt: now,
+    };
+    await writeAppState(key, request);
+    return request;
+  },
+});

package/corpus/templates/clips/actions/update-rewind-extension-request.ts

@@ -0,0 +1,47 @@
+import { defineAction } from "@agent-native/core";
+import {
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  rewindExtensionKey,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+export default defineAction({
+  description:
+    "Update the local Clips Alpha processing state for an explicit Rewind pre-roll request.",
+  schema: z.object({
+    recordingId: z.string(),
+    requestId: z.string(),
+    status: z.enum(["processing", "ready", "failed"]),
+    preRollRecordingId: z.string().optional(),
+    actualDurationMs: z.number().int().positive().optional(),
+    error: z.string().max(1200).optional(),
+  }),
+  run: async (args) => {
+    await assertAccess("recording", args.recordingId, "owner");
+    const key = rewindExtensionKey(args.recordingId);
+    const current = (await readAppState(key)) as RewindExtensionRequest | null;
+    if (!current || current.requestId !== args.requestId) {
+      throw new Error("Rewind extension request is no longer current.");
+    }
+    const next: RewindExtensionRequest = {
+      ...current,
+      status: args.status,
+      updatedAt: new Date().toISOString(),
+      ...(args.preRollRecordingId
+        ? { preRollRecordingId: args.preRollRecordingId }
+        : {}),
+      ...(args.actualDurationMs
+        ? { actualDurationMs: args.actualDurationMs }
+        : {}),
+      ...(args.error ? { error: args.error } : {}),
+    };
+    await writeAppState(key, next);
+    return next;
+  },
+});

package/corpus/templates/clips/app/components/editor/editor-layout.tsx

@@ -49,6 +49,7 @@ import {
   readPlaybackSpeedPreference,
   savePlaybackSpeedPreference,
 } from "@/lib/playback-speed";
+import { canOfferRewindHistory } from "@/lib/rewind-visibility";
 import {
   parseEdits,
   getExcludedRanges,
@@ -62,6 +63,7 @@ import { computePeaks, type WaveformPeaks } from "@/lib/waveform-peaks";
 import { ChaptersEditor } from "./chapters-editor";
 import { defaultSelectionRange } from "./editor-selection";
 import { EditorToolbar } from "./editor-toolbar";
+import { RewindExtensionDialog } from "./rewind-extension-dialog";
 import { StitchManager } from "./stitch-manager";
 import { ThumbnailPicker } from "./thumbnail-picker";
 import { Timeline } from "./timeline";
@@ -219,6 +221,7 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
 
   const [thumbOpen, setThumbOpen] = useState(false);
   const [stitchOpen, setStitchOpen] = useState(false);
+  const [rewindOpen, setRewindOpen] = useState(false);
   const [chaptersOpen, setChaptersOpen] = useState(false);
 
   const containerRef = useRef<HTMLDivElement | null>(null);
@@ -636,6 +639,10 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
         onOpenThumbnailPicker={() => setThumbOpen(true)}
         onOpenChapters={() => setChaptersOpen((v) => !v)}
         onOpenStitch={() => setStitchOpen(true)}
+        onOpenRewind={() => setRewindOpen(true)}
+        rewindAlreadyAdded={Boolean(edits.rewindOriginalStartMs)}
+        rewindAvailable={canOfferRewindHistory(playerData?.role)}
+        rewindRequiresPrivate={recording?.visibility !== "private"}
         chaptersOpen={chaptersOpen}
       />
 
@@ -739,6 +746,7 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
                   playheadMs={playheadMs}
                   chapters={chapters}
                   splitPoints={splitPoints}
+                  originalStartMs={edits.rewindOriginalStartMs}
                   onSeek={seek}
                   onClickChapter={(c) => seek(c.startMs)}
                 />
@@ -787,6 +795,23 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
         onOpenChange={setStitchOpen}
         seedRecordingId={recordingId}
       />
+      {canOfferRewindHistory(playerData?.role) ? (
+        <RewindExtensionDialog
+          open={rewindOpen}
+          onOpenChange={setRewindOpen}
+          recordingId={recordingId}
+          durationMs={durationMs}
+          videoFormat={videoFormat}
+          hasAudio={Boolean(recording.hasAudio)}
+          visibility={recording.visibility}
+          onVisibilityChanged={async () => {
+            await playerDataQuery.refetch();
+          }}
+          onApplied={async () => {
+            await playerDataQuery.refetch();
+          }}
+        />
+      ) : null}
     </div>
   );
 }