@hraness/slopcamera 3.2.7 → 3.2.8

package/src/index.ts

@@ -4,15 +4,6 @@ import {
   readDiagramFile,
   renderDiagramFile,
 } from "./artifacts.js"
-import {
-  desktopDownloadPage,
-  desktopStatus,
-  findDesktopApplication,
-  getLatestDesktopRelease,
-  installDesktop,
-  openInDesktop,
-  selectDesktopAsset,
-} from "./desktop.js"
 import {
   generateSlopcameraImage,
   generateSlopcameraImageFile,
@@ -64,27 +55,21 @@ export const slopcameraApi = Object.freeze({
   builtInIcons,
   bundledSkillPath,
   checkDiagramFile,
-  desktopDownloadPage,
-  desktopStatus,
   defineSlopcameraWorkflow,
   DiagramValidationError,
-  findDesktopApplication,
   generateSlopcameraImage,
   generateSlopcameraImageFile,
-  getLatestDesktopRelease,
   slopcameraGatewayCredentialStatus,
   slopcameraMcpProtocolVersion,
   slopcameraMcpServerName,
   slopcameraMcpTools,
   slopcameraOperationRegistry,
   SlopcameraMcpToolRuntime,
-  installDesktop,
   installSkill,
   lintDiagram,
   mcpMaximumRenderedPixels,
   mcpMaximumScale,
   mcpSourceByteLimit,
-  openInDesktop,
   parseDiagramSource,
   parseDiagramSpec,
   readDiagramFile,
@@ -97,7 +82,6 @@ export const slopcameraApi = Object.freeze({
   runSlopcameraWorkflow,
   runMcpServer,
   searchSlopcameraOperations,
-  selectDesktopAsset,
   serializeTldr,
   stackLayoutDefaults,
   StackLayoutError,
@@ -116,26 +100,20 @@ export {
   builtInIcons,
   bundledSkillPath,
   checkDiagramFile,
-  desktopDownloadPage,
-  desktopStatus,
   DiagramValidationError,
-  findDesktopApplication,
   generateSlopcameraImage,
   generateSlopcameraImageFile,
-  getLatestDesktopRelease,
   slopcameraGatewayCredentialStatus,
   slopcameraMcpProtocolVersion,
   slopcameraMcpServerName,
   slopcameraMcpTools,
   slopcameraOperationRegistry,
   SlopcameraMcpToolRuntime,
-  installDesktop,
   installSkill,
   lintDiagram,
   mcpMaximumRenderedPixels,
   mcpMaximumScale,
   mcpSourceByteLimit,
-  openInDesktop,
   parseDiagramSource,
   parseDiagramSpec,
   readDiagramFile,
@@ -147,7 +125,6 @@ export {
   resolveStackLayout,
   runMcpServer,
   searchSlopcameraOperations,
-  selectDesktopAsset,
   serializeTldr,
   stackLayoutDefaults,
   StackLayoutError,

package/src/support-completion.ts

@@ -0,0 +1,16 @@
+/** Content-free notification after useful output and owned cleanup complete. */
+export type UsefulResultObserver = () => void | Promise<void>
+
+export function reportUsefulResult(observer: UsefulResultObserver | undefined): void {
+  try {
+    if (observer !== undefined) void Promise.resolve(observer()).catch(() => undefined)
+  } catch {
+    // Optional presentation cannot change a completed operation's outcome.
+  }
+}
+
+export function quietSupportChildEnvironment(
+  env: Readonly<Record<string, string | undefined>>,
+): Record<string, string | undefined> {
+  return { ...env, HRANESS_SUPPORT_AUDIENCE: "off", HRANESS_SUPPORT_EMAIL: "off" }
+}

package/src/support.ts

@@ -0,0 +1,42 @@
+import {
+  maybeShowSupportInvitation,
+  runSupportCommand,
+  type SupportCommandOptions,
+} from "@hraness/support-foundation/node"
+
+export const supportProfile = {
+  id: "slopcamera",
+  name: "Slopcamera",
+  valueProposition: "Support ongoing development of local visual tools for agents.",
+  updates: false,
+} as const
+
+/** Called only by the real process entrypoint; imported CLI and SDK calls stay inert. */
+export function standaloneSupportEnvironment(): Readonly<Record<string, string | undefined>> {
+  const env = { ...process.env }
+  process.env.HRANESS_SUPPORT_AUDIENCE = "off"
+  process.env.HRANESS_SUPPORT_EMAIL = "off"
+  return env
+}
+
+export async function runProductSupportCommand(
+  args: readonly string[],
+  options: SupportCommandOptions = {},
+): Promise<number> {
+  const result = await runSupportCommand(supportProfile, args, {
+    command: ["slopcamera"], ...options, gitEmail: false,
+  })
+  if (result.stdout !== "") process.stdout.write(result.stdout)
+  if (result.stderr !== "") process.stderr.write(result.stderr)
+  return result.exitCode
+}
+
+export async function showProductSupportInvitation(options: SupportCommandOptions = {}): Promise<void> {
+  try {
+    await maybeShowSupportInvitation(supportProfile, {
+      usefulResult: true, command: ["slopcamera"], ...options, gitEmail: false,
+    })
+  } catch {
+    // Optional support must not alter the completed task or its stdout.
+  }
+}

package/src/version.ts

@@ -1 +1 @@
-export const SLOPCAMERA_VERSION = "3.2.7" as const
+export const SLOPCAMERA_VERSION = "3.2.8" as const

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

@@ -1,5 +0,0 @@
-export * from "./pause";
-export * from "./resume";
-export * from "./shared";
-export * from "./start";
-export * from "./stop";

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

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

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

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

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

@@ -1,199 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,
-};