@zapier/youtube-connector 0.0.0 → 0.0.1

package/scripts/subscribeToChannel.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// subscriptions.insert is a single POST, but YouTube returns subscriptionDuplicate
+// when the user is already subscribed —
+// a postcondition-satisfied "soft success". We catch it and look up the existing
+// subscription so the tool still returns a valid Subscription (with the id the
+// agent needs) rather than throwing on a state it actually wanted.
+import {
+  ConnectorHttpError,
+  defineTool,
+  handleIfScriptMain,
+} from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import {
+  hasYouTubeReason,
+  SubscriptionSchema,
+  throwForYouTube,
+} from "../lib/youtube.ts";
+
+const inputSchema = z
+  .object({
+    snippet: z
+      .object({
+        resourceId: z
+          .object({
+            kind: z.string().default("youtube#channel"),
+            channelId: z
+              .string()
+              .describe("The id (UC...) of the channel to subscribe to."),
+          })
+          .strict()
+          .describe(
+            "The channel to subscribe to. Set kind to youtube#channel and channelId to the target channel id.",
+          ),
+      })
+      .strict(),
+    part: z
+      .string()
+      .describe("Resource parts being written. Leave as the default.")
+      .default("snippet"),
+  })
+  .strict();
+
+const outputSchema = SubscriptionSchema.extend({
+  alreadySatisfied: z
+    .literal(true)
+    .describe("Present and true when the user was already subscribed.")
+    .optional(),
+  alreadySatisfiedReason: z
+    .string()
+    .describe('The upstream code, e.g. "subscriptionDuplicate".')
+    .optional(),
+});
+
+const definition = defineTool({
+  name: "subscribeToChannel",
+  title: "Subscribe To Channel",
+  description:
+    "Subscribe the authenticated user to a channel. Returns the subscription id (used by unsubscribeFromChannel — distinct from the channel id). If the user is already subscribed, returns the existing subscription with alreadySatisfied: true rather than failing.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/subscriptions`);
+    url.searchParams.set("part", input.part);
+
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ snippet: input.snippet }),
+    });
+    if (res.ok) return res.json();
+
+    // Soft-success: already subscribed → look up the existing subscription so we
+    // can return its id, flagged with alreadySatisfied.
+    if (res.status === 400) {
+      const body = (await res.json().catch(() => null)) as unknown;
+      if (hasYouTubeReason(body, "subscriptionDuplicate")) {
+        const channelId = input.snippet.resourceId.channelId;
+        const lookup = new URL(
+          `https://www.googleapis.com/youtube/v3/subscriptions`,
+        );
+        lookup.searchParams.set("part", "snippet,contentDetails");
+        lookup.searchParams.set("mine", "true");
+        lookup.searchParams.set("forChannelId", channelId);
+        const lres = await ctx.fetch(lookup.toString(), { method: "GET" });
+        await throwForYouTube(lres, "subscribeToChannel");
+        const lpayload = (await lres.json()) as {
+          items?: Array<Record<string, unknown>>;
+        };
+        const existing = lpayload.items?.[0];
+        if (existing) {
+          return {
+            ...existing,
+            alreadySatisfied: true as const,
+            alreadySatisfiedReason: "subscriptionDuplicate",
+          };
+        }
+      }
+      throw ConnectorHttpError.fromResponseBody(res, body, {
+        message: `YouTube subscribeToChannel 400: ${
+          (body as { error?: { message?: string } })?.error?.message ??
+          "bad request"
+        }`,
+      });
+    }
+
+    await throwForYouTube(res, "subscribeToChannel");
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/unsubscribeFromChannel.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { SuccessResultSchema, throwForYouTube } from "../lib/youtube.ts";
+
+const inputSchema = z
+  .object({
+    id: z
+      .string()
+      .describe(
+        "The subscription id to delete (from listSubscriptions, not the channel id).",
+      ),
+  })
+  .strict();
+const outputSchema = SuccessResultSchema;
+
+const definition = defineTool({
+  name: "unsubscribeFromChannel",
+  title: "Unsubscribe From Channel",
+  description:
+    "Unsubscribe the authenticated user from a channel. The id is the subscription id from listSubscriptions (NOT the channel id).",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    // Reversible — the user can re-subscribe with subscribeToChannel.
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/subscriptions`);
+    if (input.id !== undefined) {
+      url.searchParams.set("id", String(input.id));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "DELETE",
+    });
+    await throwForYouTube(res, "unsubscribeFromChannel");
+    return { success: true as const };
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/updatePlaylist.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { PlaylistSchema, throwForYouTube } from "../lib/youtube.ts";
+
+const inputSchema = z
+  .object({
+    id: z.string().describe("The id of the playlist to update."),
+    snippet: z
+      .object({
+        title: z.string().describe("Playlist title (required)."),
+        description: z.string().describe("Playlist description.").optional(),
+        defaultLanguage: z
+          .string()
+          .describe(
+            "BCP-47 language code of the title/description text, e.g. en.",
+          )
+          .optional(),
+      })
+      .strict(),
+    status: z
+      .object({
+        privacyStatus: z
+          .enum(["public", "unlisted", "private"])
+          .describe("Playlist visibility. Defaults to private if omitted.")
+          .optional(),
+      })
+      .strict()
+      .optional(),
+    part: z
+      .string()
+      .describe("Resource parts being written. Leave as the default.")
+      .default("snippet,status"),
+  })
+  .strict();
+const outputSchema = PlaylistSchema;
+
+const definition = defineTool({
+  name: "updatePlaylist",
+  title: "Update Playlist",
+  description:
+    "Update a playlist's title, description, or privacy. Send the complete desired snippet — omitted fields within a written part are reset (the API replaces, not merges). Resolve id via listPlaylists.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlists`);
+    if (input.part !== undefined) {
+      url.searchParams.set("part", String(input.part));
+    }
+    const body: Record<string, unknown> = {};
+    if (input.id !== undefined) body["id"] = input.id;
+    if (input.snippet !== undefined) body["snippet"] = input.snippet;
+    if (input.status !== undefined) body["status"] = input.status;
+    const res = await ctx.fetch(url.toString(), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    await throwForYouTube(res, "updatePlaylist");
+    return res.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/scripts/updateVideo.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+// This is a read-modify-write composition, not a single HTTP call. videos.update
+// REPLACES every field
+// within a written part — any mutable snippet/status field omitted from the request
+// is reset to its default. So "change just the title" must first read the current
+// snippet+status, merge the agent's changes onto it, then PUT the full object back.
+// The API also requires snippet.title and snippet.categoryId on every update, so the
+// merge carries those forward when the agent doesn't supply them.
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+import { connectionResolvers } from "../connections.ts";
+import { throwForYouTube, VideoSchema } from "../lib/youtube.ts";
+
+const inputSchema = z
+  .object({
+    video_id: z
+      .string()
+      .describe("The id of the video to update (you must own it)."),
+    title: z.string().describe("New title. Max 100 characters.").optional(),
+    description: z.string().describe("New description.").optional(),
+    tags: z
+      .array(z.string())
+      .describe("New tag list (replaces the existing tags).")
+      .optional(),
+    category_id: z
+      .string()
+      .describe("New category id (from listVideoCategories).")
+      .optional(),
+    privacy_status: z
+      .enum(["private", "public", "unlisted"])
+      .describe("New privacy status.")
+      .optional(),
+    publish_at: z
+      .string()
+      .describe(
+        "Reschedule publication (RFC3339). Requires privacy_status=private.",
+      )
+      .optional(),
+    made_for_kids: z
+      .boolean()
+      .describe("COPPA self-declaration (status.selfDeclaredMadeForKids).")
+      .optional(),
+  })
+  .strict();
+
+const outputSchema = VideoSchema;
+
+interface VideoSnippet {
+  title?: string;
+  description?: string;
+  tags?: string[];
+  categoryId?: string;
+  defaultLanguage?: string;
+  [k: string]: unknown;
+}
+interface VideoStatus {
+  privacyStatus?: string;
+  publishAt?: string;
+  selfDeclaredMadeForKids?: boolean;
+  license?: string;
+  embeddable?: boolean;
+  publicStatsViewable?: boolean;
+  [k: string]: unknown;
+}
+
+const definition = defineTool({
+  name: "updateVideo",
+  title: "Update Video",
+  description:
+    "Update an existing video's metadata (title, description, tags, category, privacy) without disturbing the fields you don't change. Reads the current video first, merges your changes, then writes — so omitting a field leaves it as-is. You must own the video.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    // 1. Read the current snippet + status.
+    const getUrl = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    getUrl.searchParams.set("part", "snippet,status");
+    getUrl.searchParams.set("id", input.video_id);
+    const getRes = await ctx.fetch(getUrl.toString(), { method: "GET" });
+    await throwForYouTube(getRes, "updateVideo");
+    const current = (await getRes.json()) as {
+      items?: Array<{ snippet?: VideoSnippet; status?: VideoStatus }>;
+    };
+    const video = current.items?.[0];
+    if (!video) {
+      throw new Error(
+        `YouTube updateVideo 404: no video found with id '${input.video_id}'. Verify the id (resolve via searchVideos/getVideo); you can only update videos you own.`,
+      );
+    }
+
+    // 2. Merge the provided fields onto the current snippet/status. The API requires
+    //    snippet.title and snippet.categoryId on update — carried forward from the
+    //    current video unless the agent overrides them. Only writable fields are sent.
+    const cur = video.snippet ?? {};
+    const snippet: VideoSnippet = {
+      title: input.title ?? cur.title,
+      categoryId: input.category_id ?? cur.categoryId,
+    };
+    if (input.description !== undefined)
+      snippet.description = input.description;
+    else if (cur.description !== undefined)
+      snippet.description = cur.description;
+    if (input.tags !== undefined) snippet.tags = input.tags;
+    else if (cur.tags !== undefined) snippet.tags = cur.tags;
+    if (cur.defaultLanguage !== undefined)
+      snippet.defaultLanguage = cur.defaultLanguage;
+
+    const curStatus = video.status ?? {};
+    const status: VideoStatus = {
+      privacyStatus: input.privacy_status ?? curStatus.privacyStatus,
+    };
+    if (input.publish_at !== undefined) status.publishAt = input.publish_at;
+    else if (curStatus.publishAt !== undefined)
+      status.publishAt = curStatus.publishAt;
+    if (input.made_for_kids !== undefined)
+      status.selfDeclaredMadeForKids = input.made_for_kids;
+    else if (curStatus.selfDeclaredMadeForKids !== undefined)
+      status.selfDeclaredMadeForKids = curStatus.selfDeclaredMadeForKids;
+    if (curStatus.license !== undefined) status.license = curStatus.license;
+
+    // 3. Write the full merged object back.
+    const putUrl = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    putUrl.searchParams.set("part", "snippet,status");
+    const putRes = await ctx.fetch(putUrl.toString(), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: input.video_id, snippet, status }),
+    });
+    await throwForYouTube(putRes, "updateVideo");
+    return putRes.json();
+  },
+});
+
+export default definition;
+
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });

package/tsup.config.ts

@@ -0,0 +1,63 @@
+/**
+ * tsup build config for connectors.
+ *
+ * Compiles index.ts (library entry, bundled) and cli.ts (CLI, bundled but
+ * with the connector's index module kept external).
+ *
+ * The cli.ts entry externalises ./index.ts → ./index.js via an esbuild plugin
+ * so that dist/cli.js imports the pre-built dist/index.js as a separate module
+ * rather than inlining scripts. Without this, each script's top-level
+ * `await handleIfScriptMain(import.meta, …)` ends up inside the single-file
+ * bundle; in Node 22.18+ import.meta.main is true for the bundle entry,
+ * causing every script to execute when the dispatch CLI starts instead of
+ * routing via runDispatchCli.
+ *
+ * Managed by @zapier/connectors-dev — do not edit; synced byte-for-byte
+ * across every connector.
+ */
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  {
+    entry: ["index.ts"],
+    format: ["esm"],
+    dts: false,
+    clean: true,
+    target: "es2022",
+    external: [
+      "@modelcontextprotocol/sdk",
+      "@zapier/zapier-sdk",
+      "zod",
+      "@zapier/connectors-sdk",
+    ],
+  },
+  {
+    entry: ["cli.ts"],
+    format: ["esm"],
+    dts: false,
+    clean: false,
+    target: "es2022",
+    external: [
+      "@modelcontextprotocol/sdk",
+      "@zapier/zapier-sdk",
+      "zod",
+      "@zapier/connectors-sdk",
+    ],
+    esbuildPlugins: [
+      {
+        name: "externalize-connector-index",
+        setup(build) {
+          // Resolve ./index.ts to the pre-built ./index.js and mark it external
+          // so scripts are not inlined into dist/cli.js. When dist/index.js is
+          // imported (not the entry), import.meta.main is false inside it and
+          // handleIfScriptMain's existing !meta.main guard suppresses per-script
+          // execution — no SDK changes required.
+          build.onResolve({ filter: /^\.\/index(\.ts)?$/ }, () => ({
+            path: "./index.js",
+            external: true,
+          }));
+        },
+      },
+    ],
+  },
+]);