@nonstrict/recordkit 0.1.0

package/License.md

@@ -0,0 +1 @@
+All rights reserved by Nonstrict B.V.

package/dist/IpcRecordKit.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'events';
+export declare class IpcRecordKit extends EventEmitter {
+    private logMessages;
+    private childProcess?;
+    private responseHandler;
+    private methodHandler;
+    initialize(recordKitCliPath: string, logMessages?: boolean): Promise<void>;
+    private write;
+    sendRequest(method: string, params: any): Promise<any>;
+    sendNotification(method: string, params: any): Promise<void>;
+    registerClosure(prefix: string, handler: (payload: any) => any): string;
+    registerMethod(method: string, handler: (payload: any) => any): void;
+    unregisterMethod(method: string): void;
+}
+//# sourceMappingURL=IpcRecordKit.d.ts.map

package/dist/IpcRecordKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IpcRecordKit.d.ts","sourceRoot":"","sources":["../src/IpcRecordKit.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAmBtC,qBAAa,YAAa,SAAQ,YAAY;IAC1C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,eAAe,CAAyC;IAChE,OAAO,CAAC,aAAa,CAAiD;IAEhE,UAAU,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqEvF,OAAO,CAAC,KAAK;IAYP,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAQtD,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,GAAG,MAAM;IAMvE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAKpE,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGzC"}

package/dist/IpcRecordKit.js

@@ -0,0 +1,120 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { spawn } from 'node:child_process';
+import * as readline from 'readline';
+export class IpcRecordKit extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.logMessages = false;
+        this.responseHandler = new Map();
+        this.methodHandler = new Map();
+    }
+    async initialize(recordKitCliPath, logMessages = false) {
+        if (this.childProcess !== undefined) {
+            throw new Error('RecordKit CLI: Already initialized.');
+        }
+        this.logMessages = logMessages;
+        this.childProcess = await new Promise((resolve, reject) => {
+            const childProcess = spawn(recordKitCliPath);
+            childProcess.on('spawn', () => { resolve(childProcess); });
+            childProcess.on('error', (error) => { reject(error); });
+        });
+        const { stdout } = this.childProcess;
+        if (!stdout) {
+            throw new Error('RecordKit CLI: No stdout stream on child process.');
+        }
+        readline.createInterface({ input: stdout }).on('line', (line) => {
+            if (logMessages) {
+                console.log("< ", line.trimEnd());
+            }
+            const message = JSON.parse(line);
+            if (message.jsonrpc !== '2.0') {
+                console.error("Invalid JSON-RPC message: ", line);
+                return;
+            }
+            if (message.result && message.id) {
+                const responseHandler = this.responseHandler.get(message.id);
+                if (!responseHandler) {
+                    console.error("Received response for unknown request: ", line);
+                    return;
+                }
+                responseHandler?.resolve(message.result);
+                this.responseHandler.delete(message.id);
+            }
+            else if (message.error && message.id) {
+                const responseHandler = this.responseHandler.get(message.id);
+                if (!responseHandler) {
+                    console.error("Received response for unknown request: ", line);
+                    return;
+                }
+                responseHandler?.reject(message.error);
+                this.responseHandler.delete(message.id);
+            }
+            else if (message.method) {
+                const methodHandler = this.methodHandler.get(message.method);
+                if (!methodHandler) {
+                    console.error("No handler installed for method: ", line);
+                    return;
+                }
+                try {
+                    const response = methodHandler(message.params); // TODO: Catch the error and send back over JSONRPC
+                    if (message.id && response) {
+                        this.write({ jsonrpc: '2.0', id: message.id, result: response });
+                    }
+                    else if (message.id) {
+                        // Missing response
+                        this.write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Method called, but no response produced.' } });
+                    }
+                    else if (response) {
+                        console.error("No response expected, throwing away result: ", response);
+                    }
+                }
+                catch (error) {
+                    if (message.id) {
+                        this.write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Method threw error.', data: error } });
+                    }
+                    else {
+                        console.error("Handler for notification with method '\(message.method)' threw an error:", error);
+                    }
+                }
+            }
+            else {
+                console.error("Invalid JSON-RPC message: ", line);
+            }
+        });
+    }
+    write(message) {
+        const stdin = this.childProcess?.stdin;
+        if (!stdin) {
+            throw new Error('RecordKit CLI: Missing stdin stream.');
+        }
+        const stringifiedMessage = JSON.stringify(message);
+        if (this.logMessages) {
+            console.log("> ", stringifiedMessage);
+        }
+        stdin.write(stringifiedMessage + "\n");
+    }
+    async sendRequest(method, params) {
+        const id = 'request_' + randomUUID();
+        const response = new Promise((resolve, reject) => { this.responseHandler.set(id, { resolve, reject }); });
+        this.write({ jsonrpc: '2.0', id, method, params });
+        return response;
+    }
+    async sendNotification(method, params) {
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    registerClosure(prefix, handler) {
+        const methodName = prefix + '_' + randomUUID();
+        this.registerMethod(methodName, handler);
+        return methodName;
+    }
+    registerMethod(method, handler) {
+        if (this.methodHandler.has(method)) {
+            throw new Error(`Method already registered: ${method}`);
+        }
+        this.methodHandler.set(method, handler);
+    }
+    unregisterMethod(method) {
+        this.methodHandler.delete(method);
+    }
+}

package/dist/RecordKit.d.ts

@@ -0,0 +1,12 @@
+import { IpcRecordKit } from "./IpcRecordKit.js";
+import { RecordingDiscovery } from "./RecordingDiscovery.js";
+import { RecordingSession, RecordingSchema, AbortReason } from "./RecordingSession.js";
+declare class RecordKit {
+    ipcRecordKitCli: IpcRecordKit;
+    initialize(cliPath: string, logRpcMessages?: boolean): Promise<void>;
+    RecordingSession(schema: RecordingSchema, onAbort: (reason: AbortReason) => void): Promise<RecordingSession>;
+    RecordingDiscovery: typeof RecordingDiscovery;
+}
+export declare let recordkit: RecordKit;
+export {};
+//# sourceMappingURL=RecordKit.d.ts.map

package/dist/RecordKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordKit.d.ts","sourceRoot":"","sources":["../src/RecordKit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEvF,cAAM,SAAS;IACX,eAAe,eAAqB;IAE9B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3E,gBAAgB,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI;IAItF,kBAAkB,4BAAqB;CAC1C;AAED,eAAO,IAAI,SAAS,WAAkB,CAAC"}

package/dist/RecordKit.js

@@ -0,0 +1,17 @@
+import { IpcRecordKit } from "./IpcRecordKit.js";
+import { RecordingDiscovery } from "./RecordingDiscovery.js";
+import { RecordingSession } from "./RecordingSession.js";
+class RecordKit {
+    constructor() {
+        this.ipcRecordKitCli = new IpcRecordKit();
+        this.RecordingDiscovery = RecordingDiscovery;
+    }
+    async initialize(cliPath, logRpcMessages = false) {
+        console.log('Initializing with path:', cliPath);
+        return this.ipcRecordKitCli.initialize(cliPath, logRpcMessages);
+    }
+    async RecordingSession(schema, onAbort) {
+        return RecordingSession.newInstance(this.ipcRecordKitCli, schema, onAbort);
+    }
+}
+export let recordkit = new RecordKit();

package/dist/RecordingDiscovery.d.ts

@@ -0,0 +1,19 @@
+interface Window {
+    windowID: number;
+    title?: string;
+    frame: Bounds;
+    level: number;
+    applicationProcessID?: number;
+    applicationName?: string;
+}
+interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class RecordingDiscovery {
+    static getWindows(): Promise<Window[]>;
+}
+export {};
+//# sourceMappingURL=RecordingDiscovery.d.ts.map

package/dist/RecordingDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordingDiscovery.d.ts","sourceRoot":"","sources":["../src/RecordingDiscovery.ts"],"names":[],"mappings":"AAEA,UAAU,MAAM;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,UAAU,MAAM;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,kBAAkB;WACd,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAG/C"}

package/dist/RecordingDiscovery.js

@@ -0,0 +1,6 @@
+import { recordkit } from "./RecordKit.js";
+export class RecordingDiscovery {
+    static async getWindows() {
+        return recordkit.ipcRecordKitCli.sendRequest('RecordingDiscovery.getWindows', {});
+    }
+}

package/dist/RecordingSession.d.ts

@@ -0,0 +1,58 @@
+import { IpcRecordKit } from "./IpcRecordKit.js";
+export type RecordingSchema = WindowBasedCropSchema;
+export interface WindowBasedCropSchema {
+    type: 'windowBasedCrop';
+    windowID: number;
+    outputDirectory?: string;
+    bundleName?: string;
+    filename?: string;
+}
+export type AbortReason = {
+    reason: 'userStopped';
+    result: RecordingResult;
+} | {
+    reason: 'interrupted';
+    result: RecordingResult;
+    error: RKError;
+} | {
+    reason: 'failed';
+    error: RKError;
+};
+export interface RecordingResult {
+    url: string;
+    info: RKBundleInfo;
+}
+export interface RKError {
+    errorGroup: string;
+    debugDescription: string;
+    userMessage?: string;
+}
+export interface RKBundleInfo {
+    files: {
+        type: 'video';
+        filename: string;
+        offset: CMTime;
+    }[];
+    timeRanges: CMTimeRange[];
+}
+export interface CMTime {
+    value: number;
+    timescale: number;
+    flags: number;
+    epoch: number;
+    seconds: number;
+}
+export interface CMTimeRange {
+    start: CMTime;
+    duration: CMTime;
+}
+export declare class RecordingSession {
+    private readonly ipcRecordKit;
+    private readonly instance;
+    static newInstance(ipcRecordKit: IpcRecordKit, schema: RecordingSchema, onAbort: (reason: AbortReason) => void): Promise<RecordingSession>;
+    constructor(ipcRecordKit: IpcRecordKit, instance: string);
+    prepare(): Promise<void>;
+    record(): Promise<void>;
+    finish(): Promise<RecordingResult>;
+}
+//# sourceMappingURL=RecordingSession.d.ts.map

package/dist/RecordingSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordingSession.d.ts","sourceRoot":"","sources":["../src/RecordingSession.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,MAAM,MAAM,eAAe,GACvB,qBAAqB,CAAA;AAEzB,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAEhB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;CAAE,GACnD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;CAAE,GACnE;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;CAAE,CAAA;AAEzC,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,YAAY,CAAA;CACrB;AAED,MAAM,WAAW,OAAO;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC5D,UAAU,EAAE,WAAW,EAAE,CAAA;CAC5B;AAED,MAAM,WAAW,MAAM;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;WAErB,WAAW,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;gBAapI,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM;IAKlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;CAG3C"}

package/dist/RecordingSession.js

@@ -0,0 +1,28 @@
+import { randomUUID } from "crypto";
+import { finalizationRegistry } from "./finalizationRegistry.js";
+export class RecordingSession {
+    static async newInstance(ipcRecordKit, schema, onAbort) {
+        let instance = 'RecordingSession_' + randomUUID();
+        const onAbortInstance = ipcRecordKit.registerClosure('RecordingSession.onAbort', onAbort);
+        await ipcRecordKit.sendRequest('RecordingSession.newInstance', { instance, schema, onAbortInstance });
+        const object = new RecordingSession(ipcRecordKit, instance);
+        finalizationRegistry.register(object, async () => {
+            await ipcRecordKit.sendRequest('RecordingSession.releaseInstance', { instance });
+            ipcRecordKit.unregisterMethod(onAbortInstance);
+        });
+        return object;
+    }
+    constructor(ipcRecordKit, instance) {
+        this.ipcRecordKit = ipcRecordKit;
+        this.instance = instance;
+    }
+    async prepare() {
+        return this.ipcRecordKit.sendRequest('RecordingSession.prepare', { instance: this.instance });
+    }
+    async record() {
+        return this.ipcRecordKit.sendRequest('RecordingSession.record', { instance: this.instance });
+    }
+    async finish() {
+        return this.ipcRecordKit.sendRequest('RecordingSession.finish', { instance: this.instance });
+    }
+}

package/dist/finalizationRegistry.d.ts

@@ -0,0 +1,4 @@
+type Destructor = () => void;
+export declare const finalizationRegistry: FinalizationRegistry<Destructor>;
+export {};
+//# sourceMappingURL=finalizationRegistry.d.ts.map

package/dist/finalizationRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalizationRegistry.d.ts","sourceRoot":"","sources":["../src/finalizationRegistry.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAC5B,eAAO,MAAM,oBAAoB,kCAAqF,CAAA"}

package/dist/finalizationRegistry.js

@@ -0,0 +1 @@
+export const finalizationRegistry = new FinalizationRegistry(async (destructor) => { await destructor(); });

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { recordkit } from './RecordKit.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { recordkit } from './RecordKit.js';

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nonstrict/recordkit",
+  "version": "0.1.0",
+  "description": "RecordKit gives you hassle-free recording in Electron apps on macOS.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.16"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublish": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "recording",
+    "screen",
+    "recorder",
+    "webcam",
+    "microphone",
+    "electron",
+    "macos",
+    "avfoundation",
+    "screencapturekit"
+  ],
+  "author": {
+    "name": "Nonstrict B.V.",
+    "email": "team+recordkit@nonstrict.com",
+    "url": "https://nonstrict.eu"
+  },
+  "license": "SEE LICENSE IN License.md",
+  "devDependencies": {
+    "@types/node": "18.19.1",
+    "typescript": "^5.3.3"
+  },
+  "volta": {
+    "node": "18.19.1"
+  }
+}