@hraness/slopcamera 3.2.4

package/apps/desktop/application/operations/recording/shared.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+
+import {
+  CapturePermissionsSchema,
+  IsoTimestampSchema,
+  MicrosecondsSchema,
+  RecordingIdSchema,
+} from "../../../contracts";
+import type {
+  ApplicationContext,
+  ApplicationRecordingController,
+} from "../../context";
+import { ApplicationError } from "../../errors";
+import type {
+  BoundedOperationSummary,
+  OperationExecutionContext,
+  OperationKind,
+  OperationPolicy,
+} from "../../operation";
+import { throwIfAborted } from "../shared";
+
+export const MAX_RECORDING_OPERATION_DISPLAYS = 16;
+
+const DisplayIdSchema = z.string().min(1).max(64);
+const DeviceIdSchema = z.string().min(1).max(256);
+
+const ExplicitDisplayIdsSchema = z.array(DisplayIdSchema)
+  .min(1)
+  .max(MAX_RECORDING_OPERATION_DISPLAYS)
+  .superRefine((displayIds, context) => {
+    if (new Set(displayIds).size !== displayIds.length) {
+      context.addIssue({
+        code: "custom",
+        message: "Explicit recording display IDs must be unique.",
+      });
+    }
+  });
+
+export const RecordingDisplaySelectionSchema = z.discriminatedUnion("kind", [
+  z.strictObject({
+    kind: z.literal("all"),
+  }),
+  z.strictObject({
+    displayIds: ExplicitDisplayIdsSchema,
+    kind: z.literal("selected"),
+  }),
+]);
+
+export const RecordingDeviceSelectionSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("disabled") }),
+  z.strictObject({ kind: z.literal("default") }),
+  z.strictObject({ deviceId: DeviceIdSchema, kind: z.literal("device") }),
+]);
+
+const RecordingStartFields = {
+  camera: RecordingDeviceSelectionSchema,
+  displays: RecordingDisplaySelectionSchema,
+  microphone: RecordingDeviceSelectionSchema,
+  strictInputs: z.boolean(),
+  systemAudio: z.boolean(),
+  typedText: z.boolean(),
+} as const;
+
+export const RecordingStartInputSchema = z.strictObject(
+  RecordingStartFields,
+);
+
+export const EffectiveRecordingConfigSchema = z.strictObject({
+  ...RecordingStartFields,
+  metadata: z.literal(true),
+});
+
+const RecordingOperationOutputFields = {
+  completedSegmentCount: z.number().int().safe().nonnegative(),
+  effectiveConfig: EffectiveRecordingConfigSchema.nullable(),
+  logicalTimeUs: MicrosecondsSchema,
+  permissions: CapturePermissionsSchema.nullable(),
+  recordingId: RecordingIdSchema.nullable(),
+  state: z.enum(["idle", "recording", "paused"]),
+  updatedAt: IsoTimestampSchema.max(64),
+} as const;
+
+export const RecordingOperationOutputSchema = z.strictObject(
+  RecordingOperationOutputFields,
+);
+
+const ControllerRecordingSnapshotSchema = z.strictObject({
+  ...RecordingOperationOutputFields,
+  recordingRoot: z.string().min(1).max(4_096).nullable(),
+});
+
+export const EmptyRecordingOperationInputSchema = z.strictObject({});
+
+export type RecordingStartInput = z.infer<typeof RecordingStartInputSchema>;
+export type RecordingOperationOutput = z.infer<
+  typeof RecordingOperationOutputSchema
+>;
+export type EmptyRecordingOperationInput = z.infer<
+  typeof EmptyRecordingOperationInputSchema
+>;
+
+export const recordingStartPolicy = {
+  cache: "none",
+  cancellable: false,
+  effect: "live-control",
+  maxDurationMs: 5 * 60_000,
+  maxFanOut: 0,
+  maxInputBytes: 32 * 1_024,
+  maxOutputBytes: 64 * 1_024,
+  preparation: [
+    "recording-metadata",
+    "screen-capture",
+    "camera",
+    "microphone",
+    "system-audio",
+    "typed-text",
+    "window-metadata",
+  ],
+  resources: [{ amount: 1, resource: "capture-device" }],
+  resume: "non-resumable-live",
+} as const satisfies OperationPolicy;
+
+export const recordingTransitionPolicy = {
+  cache: "none",
+  cancellable: false,
+  effect: "live-control",
+  maxDurationMs: 5 * 60_000,
+  maxFanOut: 0,
+  maxInputBytes: 64,
+  maxOutputBytes: 64 * 1_024,
+  preparation: [],
+  resources: [{ amount: 1, resource: "capture-device" }],
+  resume: "non-resumable-live",
+} as const satisfies OperationPolicy;
+
+function requireRecordingController(
+  application: ApplicationContext,
+): ApplicationRecordingController {
+  const controller = application.recordingController;
+  if (controller === undefined) {
+    throw new ApplicationError(
+      "unavailable",
+      "Recording controller is unavailable.",
+    );
+  }
+  return controller;
+}
+
+export function parseRecordingOperationOutput(
+  value: unknown,
+): RecordingOperationOutput {
+  const parsed = ControllerRecordingSnapshotSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new ApplicationError(
+      "invalid-data",
+      "Recording controller returned an invalid bounded snapshot.",
+    );
+  }
+  const snapshot = parsed.data;
+  return RecordingOperationOutputSchema.parse({
+    completedSegmentCount: snapshot.completedSegmentCount,
+    effectiveConfig: snapshot.effectiveConfig,
+    logicalTimeUs: snapshot.logicalTimeUs,
+    permissions: snapshot.permissions,
+    recordingId: snapshot.recordingId,
+    state: snapshot.state,
+    updatedAt: snapshot.updatedAt,
+  });
+}
+
+export async function executeRecordingControl(
+  context: OperationExecutionContext,
+  action: "pause" | "resume" | "start" | "stop",
+  options?: RecordingStartInput,
+): Promise<RecordingOperationOutput> {
+  throwIfAborted(context.abortSignal);
+  const controller = requireRecordingController(context.application);
+  await context.workflow?.beforePublication();
+  const snapshot = options === undefined
+    ? await controller.execute(action)
+    : await controller.execute(action, options);
+  return parseRecordingOperationOutput(snapshot);
+}
+
+export function summarizeRecordingControl(
+  kind: Extract<OperationKind, `recording.${string}`>,
+  output: RecordingOperationOutput,
+): BoundedOperationSummary {
+  return {
+    fields: {
+      completedSegmentCount: output.completedSegmentCount,
+      logicalTimeUs: output.logicalTimeUs,
+      recordingId: output.recordingId,
+      state: output.state,
+      updatedAt: output.updatedAt,
+    },
+    kind,
+  };
+}

package/apps/desktop/application/operations/recording/start.ts

@@ -0,0 +1,169 @@
+import { z } from "zod";
+
+import {
+  CapturePermissionsSchema,
+  IsoTimestampSchema,
+  MicrosecondsSchema,
+  RecordingIdSchema,
+} from "../../../contracts";
+import type { OperationDefinition } from "../../operation";
+import {
+  executeRecordingControl,
+  MAX_RECORDING_OPERATION_DISPLAYS,
+  RecordingOperationOutputSchema,
+  type RecordingOperationOutput,
+  RecordingStartInputSchema,
+  type RecordingStartInput,
+  recordingStartPolicy,
+  summarizeRecordingControl,
+} from "./shared";
+
+export const RecordingStartOutputSchema = RecordingOperationOutputSchema;
+export type RecordingStartOutput = RecordingOperationOutput;
+
+const RecordingDisplaySelectionV1Schema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("all-current") }),
+  z.strictObject({
+    displayIds: z.array(z.string().min(1).max(256))
+      .min(1)
+      .max(MAX_RECORDING_OPERATION_DISPLAYS)
+      .superRefine((displayIds, context) => {
+        if (new Set(displayIds).size !== displayIds.length) {
+          context.addIssue({
+            code: "custom",
+            message: "Explicit recording display IDs must be unique.",
+          });
+        }
+      }),
+    kind: z.literal("explicit"),
+  }),
+]);
+
+export const RecordingStartInputV1Schema = z.strictObject({
+  displaySelection: RecordingDisplaySelectionV1Schema,
+  microphone: z.boolean(),
+  strictInputs: z.boolean(),
+  systemAudio: z.boolean(),
+  typedText: z.boolean(),
+  webcam: z.boolean(),
+});
+
+const EffectiveRecordingConfigV1Schema = z.strictObject({
+  ...RecordingStartInputV1Schema.shape,
+  metadata: z.literal(true),
+});
+
+export const RecordingStartOutputV1Schema = z.strictObject({
+  completedSegmentCount: z.number().int().safe().nonnegative(),
+  effectiveConfig: EffectiveRecordingConfigV1Schema.nullable(),
+  logicalTimeUs: MicrosecondsSchema,
+  permissions: CapturePermissionsSchema.nullable(),
+  recordingId: RecordingIdSchema.nullable(),
+  state: z.enum(["idle", "recording", "paused"]),
+  updatedAt: IsoTimestampSchema.max(64),
+});
+
+export type RecordingStartInputV1 = z.infer<
+  typeof RecordingStartInputV1Schema
+>;
+export type RecordingStartOutputV1 = z.infer<
+  typeof RecordingStartOutputV1Schema
+>;
+
+function upgradeRecordingStartInput(
+  input: RecordingStartInputV1,
+): RecordingStartInput {
+  return RecordingStartInputSchema.parse({
+    camera: { kind: input.webcam ? "default" : "disabled" },
+    displays: input.displaySelection.kind === "all-current"
+      ? { kind: "all" }
+      : {
+          displayIds: input.displaySelection.displayIds,
+          kind: "selected",
+        },
+    microphone: { kind: input.microphone ? "default" : "disabled" },
+    strictInputs: input.strictInputs,
+    systemAudio: input.systemAudio,
+    typedText: input.typedText,
+  });
+}
+
+function downgradeRecordingStartOutput(
+  output: RecordingStartOutput,
+): RecordingStartOutputV1 {
+  const effectiveConfig = output.effectiveConfig === null
+    ? null
+    : {
+        displaySelection: output.effectiveConfig.displays.kind === "all"
+          ? { kind: "all-current" as const }
+          : {
+              displayIds: output.effectiveConfig.displays.displayIds,
+              kind: "explicit" as const,
+            },
+        metadata: true as const,
+        microphone: output.effectiveConfig.microphone.kind !== "disabled",
+        strictInputs: output.effectiveConfig.strictInputs,
+        systemAudio: output.effectiveConfig.systemAudio,
+        typedText: output.effectiveConfig.typedText,
+        webcam: output.effectiveConfig.camera.kind !== "disabled",
+      };
+  return RecordingStartOutputV1Schema.parse({
+    ...output,
+    effectiveConfig,
+  });
+}
+
+export const recordingStartOperationDefinitionV1: OperationDefinition<
+  "recording.start",
+  RecordingStartInputV1,
+  RecordingStartOutputV1
+> = {
+  inputSchema: RecordingStartInputV1Schema,
+  inputSchemaId: "slopcamera.operation.recording.start.input/v1",
+  kind: "recording.start",
+  lifecycle: {
+    kind: "live-control",
+    execute: async (context, input) => downgradeRecordingStartOutput(
+      await executeRecordingControl(
+        context,
+        "start",
+        upgradeRecordingStartInput(input),
+      ),
+    ),
+  },
+  outputSchema: RecordingStartOutputV1Schema,
+  outputSchemaId: "slopcamera.operation.recording.start.output/v1",
+  policy: recordingStartPolicy,
+  summarize: output => ({
+    fields: {
+      completedSegmentCount: output.completedSegmentCount,
+      logicalTimeUs: output.logicalTimeUs,
+      recordingId: output.recordingId,
+      state: output.state,
+      updatedAt: output.updatedAt,
+    },
+    kind: "recording.start",
+  }),
+  version: 1,
+};
+
+export const recordingStartOperationDefinition: OperationDefinition<
+  "recording.start",
+  RecordingStartInput,
+  RecordingStartOutput
+> = {
+  inputSchema: RecordingStartInputSchema,
+  inputSchemaId: "slopcamera.operation.recording.start.input/v2",
+  kind: "recording.start",
+  lifecycle: {
+    kind: "live-control",
+    execute: async (context, input) => (
+      await executeRecordingControl(context, "start", input)
+    ),
+  },
+  outputSchema: RecordingStartOutputSchema,
+  outputSchemaId: "slopcamera.operation.recording.start.output/v2",
+  policy: recordingStartPolicy,
+  summarize: output => summarizeRecordingControl("recording.start", output),
+  version: 2,
+};

package/apps/desktop/application/operations/recording/stop.ts

@@ -0,0 +1,34 @@
+import type { OperationDefinition } from "../../operation";
+import {
+  EmptyRecordingOperationInputSchema,
+  type EmptyRecordingOperationInput,
+  executeRecordingControl,
+  RecordingOperationOutputSchema,
+  type RecordingOperationOutput,
+  recordingTransitionPolicy,
+  summarizeRecordingControl,
+} from "./shared";
+
+export const RecordingStopInputSchema = EmptyRecordingOperationInputSchema;
+export const RecordingStopOutputSchema = RecordingOperationOutputSchema;
+export type RecordingStopInput = EmptyRecordingOperationInput;
+export type RecordingStopOutput = RecordingOperationOutput;
+
+export const recordingStopOperationDefinition: OperationDefinition<
+  "recording.stop",
+  RecordingStopInput,
+  RecordingStopOutput
+> = {
+  inputSchema: RecordingStopInputSchema,
+  inputSchemaId: "slopcamera.operation.recording.stop.input/v1",
+  kind: "recording.stop",
+  lifecycle: {
+    kind: "live-control",
+    execute: async context => await executeRecordingControl(context, "stop"),
+  },
+  outputSchema: RecordingStopOutputSchema,
+  outputSchemaId: "slopcamera.operation.recording.stop.output/v1",
+  policy: recordingTransitionPolicy,
+  summarize: output => summarizeRecordingControl("recording.stop", output),
+  version: 1,
+};