kap-r2 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+interface KapConfig {
+    get(key: string): string;
+}
+interface KapContext {
+    filePath(): Promise<string>;
+    config: KapConfig;
+    setProgress(text: string, percentage?: number): void;
+    copyToClipboard(text: string): void;
+    notify(text: string, action?: () => void): void;
+    cancel(): void;
+}
+export declare const shareServices: {
+    title: string;
+    formats: string[];
+    action: (context: KapContext) => Promise<void>;
+    configDescription: string;
+    config: {
+        accountId: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+        accessKeyId: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+        secretAccessKey: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+        bucket: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+        directory: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+        publicUrl: {
+            title: string;
+            type: string;
+            default: string;
+            required: boolean;
+        };
+    };
+}[];
+export {};

package/dist/index.js

@@ -0,0 +1,142 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+const contentTypes = new Map([
+    [".gif", "image/gif"],
+    [".mp4", "video/mp4"],
+    [".webm", "video/webm"],
+    [".apng", "image/apng"],
+]);
+const isValidAccountId = (id) => {
+    return /^[a-f0-9]{32}$/.test(id);
+};
+const isValidBucketName = (name) => {
+    return /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/.test(name);
+};
+const action = async (context) => {
+    const accountId = context.config.get("accountId");
+    const accessKeyId = context.config.get("accessKeyId");
+    const secretAccessKey = context.config.get("secretAccessKey");
+    const bucket = context.config.get("bucket");
+    const directory = context.config.get("directory") || "";
+    const publicUrl = context.config.get("publicUrl");
+    if (!isValidAccountId(accountId)) {
+        context.notify("Invalid Account ID. It should be a 32-character hex string.");
+        context.cancel();
+        return;
+    }
+    if (!isValidBucketName(bucket)) {
+        context.notify("Invalid Bucket Name. Use lowercase letters, numbers, and hyphens.");
+        context.cancel();
+        return;
+    }
+    if (!publicUrl.startsWith("https://")) {
+        context.notify("Public URL must start with https://");
+        context.cancel();
+        return;
+    }
+    const filePath = await context.filePath();
+    const fileStats = await stat(filePath);
+    context.setProgress("Uploading to R2…", 0);
+    const client = new S3Client({
+        region: "auto",
+        endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+        credentials: {
+            accessKeyId,
+            secretAccessKey,
+        },
+    });
+    const filename = path.basename(filePath);
+    const key = directory ? path.posix.join(directory, filename) : filename;
+    const extension = path.extname(filename);
+    const contentType = contentTypes.get(extension) || "application/octet-stream";
+    try {
+        const upload = new Upload({
+            client,
+            params: {
+                Bucket: bucket,
+                Key: key,
+                Body: createReadStream(filePath),
+                ContentType: contentType,
+            },
+            queueSize: 4,
+            partSize: 1024 * 1024 * 5,
+            leavePartsOnError: false,
+        });
+        upload.on("httpUploadProgress", (progress) => {
+            if (progress.loaded && fileStats.size) {
+                const percentage = progress.loaded / fileStats.size;
+                context.setProgress("Uploading to R2…", percentage);
+            }
+        });
+        await upload.done();
+        const baseUrl = publicUrl.replace(/\/$/, "");
+        const encodedKey = key.split("/").map(encodeURIComponent).join("/");
+        const uploadUrl = `${baseUrl}/${encodedKey}`;
+        context.copyToClipboard(uploadUrl);
+        context.notify("R2 URL copied to the clipboard");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("InvalidAccessKeyId") || message.includes("SignatureDoesNotMatch")) {
+            context.notify("Authentication failed. Check your Access Key ID and Secret.");
+        }
+        else if (message.includes("NoSuchBucket")) {
+            context.notify("Bucket not found. Check your bucket name.");
+        }
+        else if (message.includes("AccessDenied")) {
+            context.notify("Access denied. Check your API token permissions.");
+        }
+        else {
+            context.notify(`Upload failed: ${message}`);
+        }
+        context.cancel();
+    }
+};
+const r2 = {
+    title: "Share to R2",
+    formats: ["gif", "mp4", "webm", "apng"],
+    action,
+    configDescription: "Configure your Cloudflare R2 credentials. Get your API tokens from the Cloudflare dashboard under R2 > Manage R2 API Tokens.",
+    config: {
+        accountId: {
+            title: "Account ID",
+            type: "string",
+            default: "",
+            required: true,
+        },
+        accessKeyId: {
+            title: "Access Key ID",
+            type: "string",
+            default: "",
+            required: true,
+        },
+        secretAccessKey: {
+            title: "Secret Access Key",
+            type: "string",
+            default: "",
+            required: true,
+        },
+        bucket: {
+            title: "Bucket Name",
+            type: "string",
+            default: "",
+            required: true,
+        },
+        directory: {
+            title: "Directory",
+            type: "string",
+            default: "",
+            required: false,
+        },
+        publicUrl: {
+            title: "Public URL",
+            type: "string",
+            default: "",
+            required: true,
+        },
+    },
+};
+export const shareServices = [r2];

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Tristan Remy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "kap-r2",
+  "version": "1.0.1",
+  "description": "Share on Cloudflare R2",
+  "license": "MIT",
+  "repository": "tristanremy/kap-r2",
+  "author": {
+    "name": "Tristan Remy",
+    "url": "https://github.com/tristanremy"
+  },
+  "type": "module",
+  "exports": "./dist/index.js",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "kap-plugin",
+    "cloudflare",
+    "r2",
+    "upload",
+    "share",
+    "storage"
+  ],
+  "kap": {
+    "version": ">=3.0.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.728.0",
+    "@aws-sdk/lib-storage": "^3.728.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/readme.md

@@ -0,0 +1,38 @@
+# kap-r2
+
+> [Kap](https://github.com/wulkano/Kap) plugin - Share on Cloudflare R2
+
+## Install
+
+In the `Kap` menu, go to `Preferences…`, select the `Plugins` pane, find this plugin, and click `Install`.
+
+## Configuration
+
+| Setting | Description |
+|---------|-------------|
+| **Account ID** | Your Cloudflare account ID |
+| **Access Key ID** | R2 API token access key |
+| **Secret Access Key** | R2 API token secret |
+| **Bucket Name** | Name of your R2 bucket |
+| **Directory** | Optional subfolder path (e.g., `recordings/`) |
+| **Public URL** | Your bucket's public URL (R2.dev or custom domain) |
+
+### Getting R2 API Credentials
+
+1. Go to [Cloudflare Dashboard](https://dash.cloudflare.com)
+2. Navigate to **R2** > **Manage R2 API Tokens**
+3. Click **Create API Token**
+4. Grant **Object Read & Write** permissions
+5. Save the **Access Key ID** and **Secret Access Key**
+
+### Setting Up Public Access
+
+Enable the R2.dev subdomain in bucket settings or connect a custom domain.
+
+## Usage
+
+After recording in Kap, select an export format, then click **Share to R2**.
+
+## License
+
+MIT © [Tristan Remy](https://github.com/tristanremy)