Audio bump deploy

Author: nmharmon8

.github/workflows/publish-npm.yml

@@ -11,9 +11,10 @@ on:
 
 jobs:
   publish:
+    if: ${{ github.actor != 'github-actions[bot]' }}
     runs-on: ubuntu-latest
     permissions:
-      contents: read
+      contents: write
       id-token: write
     steps:
       - name: Check out repo
@@ -31,23 +32,113 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Decide whether to publish
-        id: should_publish
+      - name: Decide version
+        id: version
         run: |
           current=$(node -p "require('./package.json').version")
           published=$(npm view diffio version 2>/dev/null || true)
           echo "current=$current"
           echo "published=$published"
-          if [ "$current" = "$published" ]; then
-            echo "publish=false" >> "$GITHUB_OUTPUT"
+          CURRENT="$current" PUBLISHED="$published" node - <<'NODE'
+          const fs = require("fs");
+          const current = process.env.CURRENT;
+          const published = process.env.PUBLISHED;
+
+          const parse = (value) => {
+            const core = value.split("-")[0].split("+")[0];
+            const parts = core.split(".").map((item) => parseInt(item, 10));
+            while (parts.length < 3) {
+              parts.push(0);
+            }
+            return parts.slice(0, 3);
+          };
+
+          const compare = (left, right) => {
+            const a = parse(left);
+            const b = parse(right);
+            for (let i = 0; i < 3; i += 1) {
+              if (a[i] > b[i]) return 1;
+              if (a[i] < b[i]) return -1;
+            }
+            return 0;
+          };
+
+          const bumpPatch = (value) => {
+            const [major, minor, patch] = parse(value);
+            return `${major}.${minor}.${patch + 1}`;
+          };
+
+          let nextVersion = current;
+          let bumpNeeded = false;
+          if (published) {
+            const comparison = compare(current, published);
+            if (comparison <= 0) {
+              nextVersion = bumpPatch(comparison === 0 ? current : published);
+              bumpNeeded = true;
+            }
+          }
+
+          const publish =
+            !published || (published && compare(nextVersion, published) > 0);
+
+          const output = process.env.GITHUB_OUTPUT;
+          if (output) {
+            fs.appendFileSync(output, `next_version=${nextVersion}\n`);
+            fs.appendFileSync(
+              output,
+              `bump_needed=${bumpNeeded ? "true" : "false"}\n`
+            );
+            fs.appendFileSync(
+              output,
+              `publish=${publish ? "true" : "false"}\n`
+            );
+          }
+          NODE
+
+      - name: Bump package.json version
+        if: ${{ steps.version.outputs.bump_needed == 'true' }}
+        run: npm version "${{ steps.version.outputs.next_version }}" --no-git-tag-version
+
+      - name: Sync SDK version constant
+        id: sync_version
+        env:
+          NEXT_VERSION: ${{ steps.version.outputs.next_version }}
+        run: |
+          node - <<'NODE'
+          const fs = require("fs");
+          const path = "src/version.ts";
+          const nextVersion = process.env.NEXT_VERSION;
+          if (!nextVersion) {
+            process.exit(0);
+          }
+          const contents = fs.readFileSync(path, "utf8");
+          const updated = contents.replace(
+            /DIFFIO_SDK_VERSION\s*=\s*["'][^"']+["']/,
+            `DIFFIO_SDK_VERSION = "${nextVersion}"`
+          );
+          if (updated !== contents) {
+            fs.writeFileSync(path, updated);
+          }
+          NODE
+          if git diff --quiet -- package.json package-lock.json src/version.ts; then
+            echo "changed=false" >> "$GITHUB_OUTPUT"
           else
-            echo "publish=true" >> "$GITHUB_OUTPUT"
+            echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
+      - name: Commit version update
+        if: ${{ steps.sync_version.outputs.changed == 'true' }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add package.json package-lock.json src/version.ts
+          git commit -m "chore(release): bump JS SDK to ${{ steps.version.outputs.next_version }}"
+          git push origin "HEAD:${GITHUB_REF_NAME}"
+
       - name: Build
-        if: ${{ steps.should_publish.outputs.publish == 'true' }}
+        if: ${{ steps.version.outputs.publish == 'true' }}
         run: npm run build
 
       - name: Publish to npm
-        if: ${{ steps.should_publish.outputs.publish == 'true' }}
+        if: ${{ steps.version.outputs.publish == 'true' }}
         run: npm publish --access public

README.md

@@ -17,17 +17,11 @@ npm install
 
 ## Configuration
 
-Set the API key with `DIFFIO_API_KEY`. You can also override the base URL with `DIFFIO_API_BASE_URL`.
+Set the API key with `DIFFIO_API_KEY`. If you need to set the base URL explicitly, use the production endpoint with `DIFFIO_API_BASE_URL`.
 
 ```bash
 export DIFFIO_API_KEY="diffio_live_..."
-export DIFFIO_API_BASE_URL="https://us-central1-diffioai.cloudfunctions.net"
-```
-
-For emulators, set the base URL to the Functions emulator host.
-
-```bash
-export DIFFIO_API_BASE_URL="http://127.0.0.1:5001/diffioai/us-central1"
+export DIFFIO_API_BASE_URL="https://us-central1-diffioai.cloudfunctions.net/v1"
 ```
 
 ## Request options
@@ -166,16 +160,6 @@ for (const generation of generations.generations) {
 }
 ```
 
-## Webhooks portal access
-
-```ts
-import { DiffioClient } from "diffio";
-
-const client = new DiffioClient({ apiKey: "diffio_live_..." });
-const portal = await client.webhooks.getPortalAccess({ mode: "test" });
-console.log(portal.portalUrl);
-```
-
 ## Send a test webhook event
 
 ```ts
@@ -184,13 +168,46 @@ import { DiffioClient } from "diffio";
 const client = new DiffioClient({ apiKey: "diffio_live_..." });
 const event = await client.webhooks.sendTestEvent({
   eventType: "generation.completed",
-  mode: "test",
+  mode: "live",
   samplePayload: { apiProjectId: "proj_123" }
 });
 
 console.log(event.svixMessageId);
 ```
 
+## Verify webhook signatures
+
+Use the raw request body (not parsed JSON) plus the `svix-*` headers and your webhook signing secret.
+
+```ts
+import express from "express";
+import { DiffioClient } from "diffio";
+
+const app = express();
+const client = new DiffioClient({ apiKey: process.env.DIFFIO_API_KEY });
+
+app.post("/webhooks/diffio", express.raw({ type: "application/json" }), (req, res) => {
+  const payload = req.body;
+  const headers = {
+    "svix-id": req.header("svix-id"),
+    "svix-timestamp": req.header("svix-timestamp"),
+    "svix-signature": req.header("svix-signature")
+  };
+
+  try {
+    const event = client.webhooks.verifySignature({
+      payload,
+      headers,
+      secret: process.env.DIFFIO_WEBHOOK_SECRET
+    });
+    console.log("Webhook received", event.eventType);
+    res.status(200).send("ok");
+  } catch (err) {
+    res.status(400).send("Invalid signature");
+  }
+});
+```
+
 ## Runtime compatibility
 
 Use Node 18 or later so `fetch` is available without extra packages.

package-lock.json

@@ -22,7 +22,8 @@
     "test:wire": "jest --selectProjects wire"
   },
   "dependencies": {
-    "mime-types": "^2.1.35"
+    "mime-types": "^2.1.35",
+    "svix": "^1.84.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package.json

@@ -13,7 +13,6 @@ import {
   parseGenerationProgressResponse,
   parseListProjectGenerationsResponse,
   parseListProjectsResponse,
-  parseWebhookPortalResponse,
   parseWebhookTestEventResponse
 } from "./api/serialization";
 import type {
@@ -25,7 +24,6 @@ import type {
   ListProjectGenerationsResponse,
   ListProjectsResponse,
   RestoreMetadata,
-  WebhookPortalResponse,
   WebhookTestEventResponse
 } from "./api/types";
 import { AudioIsolationClient, GenerationsClient, ProjectsClient, WebhooksClient } from "./api/resources";
@@ -290,25 +288,6 @@ export class DiffioClient {
     return parseGenerationDownloadResponse(response);
   }
 
-  async getWebhooksPortalAccess(options: {
-    mode: string;
-    apiKeyId?: string;
-    requestOptions?: DiffioClient.RequestOptions;
-  }): Promise<WebhookPortalResponse> {
-    const { mode, apiKeyId, requestOptions } = options;
-    if (!WEBHOOK_MODES.includes(mode)) {
-      throw new DiffioApiError("mode must be test or live");
-    }
-
-    const payload: Record<string, unknown> = { mode };
-    if (apiKeyId != null) {
-      payload.apiKeyId = apiKeyId;
-    }
-
-    const response = await this._requestJson("POST", "webhooks/app_portal_access", payload, requestOptions);
-    return parseWebhookPortalResponse(response);
-  }
-
   async sendWebhookTestEvent(options: {
     eventType: string;
     mode: string;