mcp-yoto 0.1.0

package/dist/main.js

@@ -0,0 +1,1958 @@
+import { createRequire } from 'module';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/server';
+import { z } from 'zod';
+import { createServer as createServer$1 } from 'http';
+import { spawn } from 'child_process';
+import { randomBytes, createHash } from 'crypto';
+import { readFile, mkdir, copyFile, writeFile, rename, chmod, rm, stat, open } from 'fs/promises';
+import { homedir } from 'os';
+import { dirname, join, basename, isAbsolute, resolve } from 'path';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import { createReadStream } from 'fs';
+import { Readable } from 'stream';
+
+// src/main.ts
+function registerPrompts(server) {
+  server.registerPrompt("bedtime_playlist_card", {
+    title: "Bedtime playlist card",
+    description: "Draft a new Yoto card from a list of audio files or URLs, ready to upload as a bedtime playlist.",
+    argsSchema: {
+      files: z.string().describe("The audio files/URLs to include, one per line or comma-separated, in play order."),
+      childName: z.string().optional().describe("The child's name, for a personalised card title.")
+    }
+  }, async (args) => {
+    const childPart = args.childName ? ` for ${args.childName}` : "";
+    const titleHint = args.childName ? ` mentioning ${args.childName}` : "";
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Build a bedtime playlist card${childPart} from these tracks, in order:
+
+${args.files}
+
+For each one: call yoto_upload_audio (or yoto_add_track once the card exists) to get a mediaRef, then call yoto_create_card with all the resulting tracks. Give the card a warm, bedtime-appropriate title${titleHint}, and ask before uploading anything.`
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("audit_card", {
+    title: "Audit a Yoto card",
+    description: "Review one Yoto card's chapters, tracks and icons for anything that looks off.",
+    argsSchema: {
+      cardId: z.string().describe("The Yoto card to audit.")
+    }
+  }, async (args) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Call yoto_get_card with cardId "${args.cardId}", then check: every chapter has a title and at least one track; track durations look sensible (not zero, not implausibly long); icons (icon16x16) are set where it would help a child navigate; chapter and track ordering makes sense. Report anything worth fixing, and ask before calling yoto_update_card.`
+        }
+      }
+    ]
+  }));
+}
+var displaySchema = z.looseObject({ icon16x16: z.string().nullable().optional() }).nullable().optional();
+var trackSchema = z.looseObject({
+  key: z.string(),
+  title: z.string(),
+  trackUrl: z.string(),
+  type: z.string().optional(),
+  duration: z.number().optional(),
+  fileSize: z.number().optional(),
+  channels: z.string().optional(),
+  format: z.string().optional(),
+  overlayLabel: z.string().optional(),
+  display: displaySchema
+});
+var chapterSchema = z.looseObject({
+  key: z.string(),
+  title: z.string(),
+  overlayLabel: z.string().optional(),
+  tracks: z.array(trackSchema).default([]),
+  duration: z.number().optional(),
+  fileSize: z.number().optional(),
+  display: displaySchema
+});
+var cardContentSchema = z.looseObject({
+  chapters: z.array(chapterSchema).default([])
+});
+var cardSchema = z.looseObject({
+  cardId: z.string(),
+  title: z.string(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+  deleted: z.boolean().optional(),
+  content: cardContentSchema.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var listCardsResponseSchema = z.looseObject({ cards: z.array(cardSchema).default([]) });
+var getCardResponseSchema = z.looseObject({ card: cardSchema });
+var upsertCardResponseSchema = z.looseObject({ card: cardSchema });
+var deviceSchema = z.looseObject({
+  deviceId: z.string(),
+  name: z.string().optional(),
+  online: z.boolean().optional(),
+  deviceFamily: z.string().optional(),
+  deviceType: z.string().optional(),
+  releaseChannel: z.string().optional(),
+  description: z.string().optional()
+});
+var listDevicesResponseSchema = z.looseObject({
+  devices: z.array(deviceSchema).default([])
+});
+var deviceConfigSchema = z.record(z.string(), z.unknown());
+var getDeviceConfigResponseSchema = z.looseObject({
+  device: z.looseObject({
+    deviceId: z.string().optional(),
+    config: deviceConfigSchema.optional()
+  }).optional()
+});
+var iconSchema = z.looseObject({
+  mediaId: z.string(),
+  displayIconId: z.string().optional(),
+  title: z.string().optional(),
+  url: z.string().optional(),
+  publicTags: z.array(z.string()).optional()
+});
+var listPublicIconsResponseSchema = z.looseObject({
+  displayIcons: z.array(iconSchema).default([])
+});
+var uploadIconResponseSchema = z.looseObject({ displayIcon: iconSchema });
+var familyLibraryGroupSchema = z.looseObject({
+  groupId: z.string().optional(),
+  name: z.string().optional()
+});
+var listFamilyLibraryResponseSchema = z.looseObject({
+  groups: z.array(familyLibraryGroupSchema).default([])
+});
+var uploadUrlResponseSchema = z.looseObject({
+  upload: z.looseObject({
+    uploadId: z.string(),
+    uploadUrl: z.string().nullable()
+  })
+});
+var transcodedResponseSchema = z.looseObject({
+  transcode: z.looseObject({
+    transcodedSha256: z.string().optional(),
+    transcodedInfo: z.looseObject({
+      duration: z.number().optional(),
+      fileSize: z.number().optional(),
+      channels: z.string().optional(),
+      format: z.string().optional()
+    }).optional()
+  })
+});
+
+// ../../packages/core/dist/yoto/endpoints.js
+async function listMyCards(client) {
+  const result = await client.request({
+    method: "GET",
+    path: "/content/mine",
+    schema: listCardsResponseSchema
+  });
+  return result.cards;
+}
+async function getCard(client, cardId) {
+  const result = await client.request({
+    method: "GET",
+    path: `/content/${encodeURIComponent(cardId)}`,
+    schema: getCardResponseSchema
+  });
+  return result.card;
+}
+async function upsertCard(client, body) {
+  const result = await client.request({
+    method: "POST",
+    path: "/content",
+    body,
+    schema: upsertCardResponseSchema,
+    idempotent: typeof body.cardId === "string" && body.cardId.length > 0
+  });
+  return result.card;
+}
+async function deleteCard(client, cardId) {
+  await client.request({
+    method: "DELETE",
+    path: `/content/${encodeURIComponent(cardId)}`,
+    idempotent: true
+  });
+}
+async function listPublicIcons(client) {
+  const result = await client.request({
+    method: "GET",
+    path: "/media/displayIcons/user/yoto",
+    schema: listPublicIconsResponseSchema
+  });
+  return result.displayIcons;
+}
+async function uploadCustomIcon(client, bytes, contentType, options = {}) {
+  const result = await client.request({
+    method: "POST",
+    path: "/media/displayIcons/user/me/upload",
+    query: { autoConvert: options.autoConvert ?? false, filename: options.filename },
+    // Wrapped in a Blob rather than passed as a raw Uint8Array: TypeScript's
+    // lib.dom BodyInit union doesn't line up with the generic-parameterised
+    // Uint8Array<ArrayBufferLike> this project's TS/lib versions infer for a
+    // bare `Uint8Array` type, but a Blob sidesteps that friction cleanly and
+    // uploads the identical bytes.
+    rawBody: new Blob([bytes]),
+    contentType,
+    schema: uploadIconResponseSchema
+  });
+  return result.displayIcon;
+}
+async function listDevices(client) {
+  const result = await client.request({
+    method: "GET",
+    path: "/device-v2/devices/mine",
+    schema: listDevicesResponseSchema
+  });
+  return result.devices;
+}
+async function getDeviceConfig(client, deviceId) {
+  const result = await client.request({
+    method: "GET",
+    path: `/device-v2/${encodeURIComponent(deviceId)}/config`,
+    schema: getDeviceConfigResponseSchema
+  });
+  return result.device?.config ?? {};
+}
+async function listFamilyLibrary(client) {
+  const result = await client.request({
+    method: "GET",
+    path: "/card/family/library/groups",
+    schema: listFamilyLibraryResponseSchema
+  });
+  return result.groups;
+}
+async function getUploadUrl(client, options = {}) {
+  return client.request({
+    method: "GET",
+    path: "/media/transcode/audio/uploadUrl",
+    query: options,
+    schema: uploadUrlResponseSchema
+  });
+}
+async function getTranscodedStatus(client, uploadId, loudnorm) {
+  return client.request({
+    method: "GET",
+    path: `/media/upload/${encodeURIComponent(uploadId)}/transcoded`,
+    query: { loudnorm },
+    schema: transcodedResponseSchema,
+    idempotent: true
+  });
+}
+
+// ../../packages/core/dist/resources.js
+function registerResources(server, deps) {
+  server.registerResource("yoto-cards", "yoto://cards", {
+    title: "Your Yoto cards",
+    description: "The signed-in parent's MYO (Make Your Own) cards.",
+    mimeType: "application/json"
+  }, async (uri) => {
+    const cards = await listMyCards(deps.client);
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: "application/json",
+          text: JSON.stringify(cards, null, 2)
+        }
+      ]
+    };
+  });
+  server.registerResource("yoto-card", new ResourceTemplate("yoto://card/{cardId}", { list: void 0 }), {
+    title: "A Yoto card",
+    description: "One card's full details -- every chapter and track.",
+    mimeType: "application/json"
+  }, async (uri, variables) => {
+    const cardId = Array.isArray(variables.cardId) ? variables.cardId[0] : variables.cardId;
+    const card = await getCard(deps.client, String(cardId));
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: "application/json",
+          text: JSON.stringify(card, null, 2)
+        }
+      ]
+    };
+  });
+  server.registerResource("yoto-icons-public", "yoto://icons/public", {
+    title: "Yoto's public icon catalogue",
+    description: "Searchable 16x16 pixel-art icons available to every account.",
+    mimeType: "application/json"
+  }, async (uri) => {
+    const icons = await listPublicIcons(deps.client);
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: "application/json",
+          text: JSON.stringify(icons, null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// ../../packages/core/dist/errors.js
+var YotoError = class extends Error {
+  code;
+  retryable;
+  hint;
+  status;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "YotoError";
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.hint = options.hint;
+    this.status = options.status;
+  }
+};
+function isYotoError(value) {
+  return value instanceof YotoError;
+}
+function toToolResult(error) {
+  if (isYotoError(error)) {
+    const suffix = error.hint ? ` (${error.hint})` : "";
+    return {
+      isError: true,
+      content: [{ type: "text", text: `${error.code}: ${error.message}${suffix}` }],
+      structuredContent: { code: error.code, message: error.message, hint: error.hint }
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    isError: true,
+    content: [{ type: "text", text: `UPSTREAM_ERROR: ${message}` }],
+    structuredContent: { code: "UPSTREAM_ERROR", message }
+  };
+}
+
+// ../../packages/core/dist/tools/_helpers.js
+var DEFAULT_ICON_BASE_URL = "https://raw.githubusercontent.com/danpillay87/mcp-yoto/main/apps/worker/public/icons";
+function defineTool(server, spec, deps) {
+  const iconBaseUrl = deps.iconBaseUrl ?? DEFAULT_ICON_BASE_URL;
+  const registerTool = server.registerTool.bind(server);
+  registerTool(spec.name, {
+    title: spec.title,
+    description: spec.description,
+    inputSchema: spec.inputSchema,
+    outputSchema: spec.outputSchema,
+    annotations: spec.annotations,
+    icons: [{ src: `${iconBaseUrl}/${spec.group}.png`, mimeType: "image/png", sizes: ["64x64"] }]
+  }, async (args) => {
+    try {
+      const output = await spec.handler(args, { logger: deps.logger });
+      const text = spec.summary(output, args);
+      return { content: [{ type: "text", text }], structuredContent: output };
+    } catch (error) {
+      if (isYotoError(error))
+        return toToolResult(error);
+      deps.logger.error(`Tool ${spec.name} failed unexpectedly`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return toToolResult(new YotoError(error instanceof Error ? error.message : String(error), {
+        code: "UPSTREAM_ERROR"
+      }));
+    }
+  });
+}
+var READ_ONLY_ANNOTATIONS = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createAuthTools(deps) {
+  const yotoStatus = {
+    name: "yoto_status",
+    title: "Check Yoto sign-in status",
+    description: "Reports whether this connection is signed in to Yoto, which mode it's running in (cli or remote), where the credential is stored, its granted scopes, and whether the Yoto API is currently reachable.",
+    group: "auth",
+    annotations: READ_ONLY_ANNOTATIONS,
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+      signedIn: z.boolean(),
+      mode: z.enum(["cli", "remote"]),
+      tokenStore: z.enum(["keychain", "file", "remote"]).optional(),
+      expiresAt: z.number().optional(),
+      scopes: z.array(z.string()).optional(),
+      hint: z.string().optional(),
+      apiReachable: z.boolean().optional()
+    }),
+    summary: (output) => output.signedIn ? `Signed in to Yoto (${output.mode} mode)${output.apiReachable === false ? " -- API unreachable right now" : ""}.` : `Not signed in to Yoto.${output.hint ? ` ${output.hint}` : ""}`,
+    handler: async () => {
+      const status = await deps.auth.status();
+      let apiReachable;
+      if (status.signedIn) {
+        try {
+          await listMyCards(deps.client);
+          apiReachable = true;
+        } catch {
+          apiReachable = false;
+        }
+      }
+      return { ...status, apiReachable };
+    }
+  };
+  const yotoSignIn = {
+    name: "yoto_sign_in",
+    title: "Sign in to Yoto",
+    description: "CLI mode: launches a local PKCE sign-in flow (opens your browser to Yoto's login page and waits for the callback). Remote mode: this connector runs on a server with nothing to launch, so it returns instructions to sign in from your AI client's connector settings instead -- that flow redirects to Yoto's own login page too.",
+    group: "auth",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      openBrowser: z.boolean().optional().describe("CLI only: open the sign-in URL automatically. Default true.")
+    }),
+    outputSchema: z.object({
+      url: z.string().optional(),
+      message: z.string()
+    }),
+    // Include the URL in the tool's text, not just structuredContent.url --
+    // an MCP client typically only renders the text back to the human, and
+    // that's the one thing a headless/no-default-browser box needs to see.
+    summary: (output) => output.url ? `${output.message}
+
+${output.url}` : output.message,
+    handler: async (args) => {
+      if (deps.mode === "remote") {
+        return {
+          message: "This is a remote connector -- sign in from your AI client's connector/integration settings, which redirects you to Yoto's own login page. There's nothing to run here."
+        };
+      }
+      if (!deps.auth.signIn) {
+        throw new YotoError("Sign-in isn't available on this connection.", {
+          code: "UNSUPPORTED_IN_MODE"
+        });
+      }
+      return deps.auth.signIn({ openBrowser: args.openBrowser });
+    }
+  };
+  const yotoSignOut = {
+    name: "yoto_sign_out",
+    title: "Sign out of Yoto",
+    description: "CLI mode: deletes the locally stored Yoto credential (keychain or file). Remote mode: this server never stores your Yoto token at all, so it returns instructions for disconnecting from your AI client and revoking access at Yoto directly. Requires confirm: true.",
+    group: "auth",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      confirm: z.boolean().describe("Must be true -- this clears your stored Yoto credential.")
+    }),
+    outputSchema: z.object({ message: z.string() }),
+    summary: (output) => output.message,
+    handler: async (args) => {
+      if (!args.confirm) {
+        throw new YotoError("Pass confirm: true to sign out.", {
+          code: "VALIDATION",
+          hint: "This clears your locally stored Yoto credential."
+        });
+      }
+      if (deps.mode === "remote") {
+        return {
+          message: "This server never stores your Yoto token -- disconnect it from your AI client's connector settings, and optionally revoke access in your Yoto account's security settings."
+        };
+      }
+      if (!deps.auth.signOut) {
+        throw new YotoError("Sign-out isn't available on this connection.", {
+          code: "UNSUPPORTED_IN_MODE"
+        });
+      }
+      await deps.auth.signOut();
+      return { message: "Signed out of Yoto. Run yoto_sign_in to reconnect." };
+    }
+  };
+  return [yotoStatus, yotoSignIn, yotoSignOut];
+}
+var cardIdSchema = z.string().min(1, "cardId must not be empty");
+z.object({
+  groups: z.array(familyLibraryGroupSchema),
+  note: z.string()
+});
+var FAMILY_LIBRARY_NOTE = 'Family library groups are shared collections, not individual MYO cards -- use yoto_get_card only with a cardId from source: "myo".';
+async function summariseFamilyLibrary(client) {
+  const groups = await listFamilyLibrary(client);
+  return { groups, note: FAMILY_LIBRARY_NOTE };
+}
+
+// ../../packages/core/dist/tools/content.js
+function createContentTools(deps) {
+  const yotoListCards = {
+    name: "yoto_list_cards",
+    title: "List your Yoto cards",
+    description: `Lists cards in your own MYO (Make Your Own) library, or the shared family library's groups. Family groups are collections, not individual cards -- see the returned note when source is "family".`,
+    group: "content",
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      source: z.enum(["myo", "family"]).default("myo"),
+      limit: z.number().int().positive().max(200).optional(),
+      cursor: z.string().optional().describe("Reserved for future pagination; currently unused.")
+    }),
+    outputSchema: z.object({
+      source: z.enum(["myo", "family"]),
+      cards: z.array(cardSchema).optional(),
+      groups: z.array(z.looseObject({ groupId: z.string().optional(), name: z.string().optional() })).optional(),
+      note: z.string().optional()
+    }),
+    summary: (output) => output.source === "family" ? `${output.groups?.length ?? 0} family library group(s).` : `${output.cards?.length ?? 0} card(s) in your MYO library.`,
+    handler: async (args) => {
+      if (args.source === "family") {
+        const { groups, note } = await summariseFamilyLibrary(deps.client);
+        return { source: "family", groups, note };
+      }
+      const cards = await listMyCards(deps.client);
+      return { source: "myo", cards: args.limit ? cards.slice(0, args.limit) : cards };
+    }
+  };
+  const yotoGetCard = {
+    name: "yoto_get_card",
+    title: "Get a Yoto card's details",
+    description: "Fetches one MYO card's full details, including every chapter and track.",
+    group: "content",
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({ cardId: cardIdSchema }),
+    outputSchema: z.object({ card: cardSchema }),
+    summary: (output) => `"${output.card.title}" -- ${output.card.content?.chapters.length ?? 0} chapter(s).`,
+    handler: async (args) => ({ card: await getCard(deps.client, args.cardId) })
+  };
+  const yotoCreateCard = {
+    name: "yoto_create_card",
+    title: "Create a new Yoto card",
+    description: "Creates a new MYO card with the given title, and optionally an initial set of tracks (each a mediaRef from yoto_upload_audio, one track per chapter) and a default icon for those chapters.",
+    group: "content",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      title: z.string().min(1),
+      tracks: z.array(z.object({
+        mediaRef: z.string().min(1).describe("A yoto:#<sha256> reference from yoto_upload_audio."),
+        title: z.string().optional()
+      })).optional(),
+      iconRef: z.string().optional().describe("A yoto:#<mediaId> icon reference, e.g. from yoto_upload_icon.")
+    }),
+    outputSchema: z.object({ card: cardSchema }),
+    summary: (output) => `Created "${output.card.title}" (${output.card.cardId}).`,
+    handler: async (args) => {
+      const tracks = args.tracks ?? [];
+      const chapters = tracks.map((track, index) => {
+        const key = String(index + 1).padStart(2, "0");
+        const title = track.title ?? args.title;
+        return {
+          key,
+          title,
+          overlayLabel: String(index + 1),
+          ...args.iconRef ? { display: { icon16x16: args.iconRef } } : {},
+          tracks: [
+            {
+              key,
+              title,
+              trackUrl: track.mediaRef,
+              type: "audio",
+              overlayLabel: String(index + 1),
+              ...args.iconRef ? { display: { icon16x16: args.iconRef } } : {}
+            }
+          ]
+        };
+      });
+      const card = await upsertCard(deps.client, { title: args.title, content: { chapters } });
+      return { card };
+    }
+  };
+  const yotoUpdateCard = {
+    name: "yoto_update_card",
+    title: "Update a Yoto card",
+    description: "Shallow-merges patch fields (e.g. title, or a full replacement content.chapters array to rename/reorder tracks or set icons) onto an existing card, then saves it.",
+    group: "content",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      cardId: cardIdSchema,
+      patch: z.record(z.string(), z.unknown()).describe("Fields to merge onto the existing card, e.g. { title } or { content }.")
+    }),
+    outputSchema: z.object({ card: cardSchema }),
+    summary: (output) => `Updated "${output.card.title}" (${output.card.cardId}).`,
+    handler: async (args) => {
+      const existing = await getCard(deps.client, args.cardId);
+      const merged = { ...existing, ...args.patch, cardId: args.cardId };
+      const card = await upsertCard(deps.client, merged);
+      return { card };
+    }
+  };
+  const yotoDeleteCard = {
+    name: "yoto_delete_card",
+    title: "Delete a Yoto card",
+    description: "Permanently deletes a MYO card from the parent's Yoto library. Requires confirm: true.",
+    group: "content",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      cardId: cardIdSchema,
+      confirm: z.boolean().describe("Must be true -- this permanently deletes the card.")
+    }),
+    outputSchema: z.object({ cardId: z.string(), deleted: z.boolean() }),
+    summary: (output) => `Deleted card ${output.cardId}.`,
+    handler: async (args) => {
+      if (!args.confirm) {
+        throw new YotoError("Pass confirm: true to delete this card.", {
+          code: "VALIDATION",
+          hint: "This permanently deletes the card from the parent's Yoto library."
+        });
+      }
+      await deleteCard(deps.client, args.cardId);
+      return { cardId: args.cardId, deleted: true };
+    }
+  };
+  return [yotoListCards, yotoGetCard, yotoCreateCard, yotoUpdateCard, yotoDeleteCard];
+}
+var READ_ONLY_ANNOTATIONS2 = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createDeviceTools(deps) {
+  const yotoListDevices = {
+    name: "yoto_list_devices",
+    title: "List your Yoto devices",
+    description: "Lists the family's Yoto players -- name, online status, and device type. View-only.",
+    group: "devices",
+    annotations: READ_ONLY_ANNOTATIONS2,
+    inputSchema: z.object({}),
+    outputSchema: z.object({ devices: z.array(deviceSchema) }),
+    summary: (output) => `${output.devices.length} device(s).`,
+    handler: async () => ({ devices: await listDevices(deps.client) })
+  };
+  const yotoGetDeviceConfig = {
+    name: "yoto_get_device_config",
+    title: "Get a Yoto device's configuration",
+    description: "Fetches one player's device configuration (clock face, volume limits, right-hand-button shortcuts, etc). This is a beta Yoto endpoint that needs a device-management scope this server intentionally never requests, so expect a FORBIDDEN_SCOPE result with a hint rather than data.",
+    group: "devices",
+    annotations: READ_ONLY_ANNOTATIONS2,
+    inputSchema: z.object({ deviceId: z.string().min(1) }),
+    outputSchema: z.object({ config: z.record(z.string(), z.unknown()) }),
+    summary: () => "Fetched device configuration.",
+    handler: async (args) => {
+      try {
+        return { config: await getDeviceConfig(deps.client, args.deviceId) };
+      } catch (error) {
+        if (isYotoError(error) && error.code === "FORBIDDEN_SCOPE") {
+          throw new YotoError("Device configuration needs a scope this connection doesn't have.", {
+            code: "FORBIDDEN_SCOPE",
+            status: error.status,
+            hint: "Yoto's device-config endpoint is in beta and requires family:devices:manage, which this server deliberately doesn't request (it only asks for family:devices:view, to stay eligible for Yoto's Verified listing). Use the Yoto app's right-hand-button shortcuts screen instead."
+          });
+        }
+        throw error;
+      }
+    }
+  };
+  return [yotoListDevices, yotoGetDeviceConfig];
+}
+var httpsUrl = z.string().url().refine((value) => value.startsWith("https://"), { message: "Must be an https:// URL." });
+function createIconTools(deps) {
+  const yotoSearchIcons = {
+    name: "yoto_search_icons",
+    title: "Search Yoto's icon catalogue",
+    description: "Searches Yoto's public catalogue of 16x16 pixel-art icons by title or tag, for use as a chapter/track icon (iconRef) when creating or updating a card.",
+    group: "icons",
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      query: z.string().optional().describe("Free-text match against the icon's title and tags."),
+      tags: z.array(z.string()).optional().describe("Icon must carry every one of these tags."),
+      limit: z.number().int().positive().max(100).optional()
+    }),
+    outputSchema: z.object({ icons: z.array(iconSchema) }),
+    summary: (output) => `${output.icons.length} icon(s) found.`,
+    handler: async (args) => {
+      const all = await listPublicIcons(deps.client);
+      let filtered = all;
+      if (args.query) {
+        const query = args.query.toLowerCase();
+        filtered = filtered.filter((icon) => icon.title?.toLowerCase().includes(query) || icon.publicTags?.some((tag) => tag.toLowerCase().includes(query)));
+      }
+      if (args.tags?.length) {
+        const wantedTags = args.tags;
+        filtered = filtered.filter((icon) => wantedTags.every((tag) => icon.publicTags?.includes(tag)));
+      }
+      return { icons: args.limit ? filtered.slice(0, args.limit) : filtered };
+    }
+  };
+  const imageInputShape = deps.mode === "cli" ? {
+    imagePath: z.string().min(1).describe("Absolute path to a local image file (PNG, JPEG, or SVG).")
+  } : {
+    imageUrl: httpsUrl.describe("An https:// URL to an image file (PNG, JPEG, or SVG) -- this connector runs remotely, so give a link, not a file path.")
+  };
+  const yotoUploadIcon = {
+    name: "yoto_upload_icon",
+    title: "Upload a custom Yoto icon",
+    description: "Uploads a custom 16x16 pixel-art icon to your Yoto account, returning a mediaId usable as an iconRef on cards and tracks. " + (deps.mode === "cli" ? "Runs locally, so it takes a file path." : "This connector runs remotely, so it takes a link, not a file path."),
+    group: "icons",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: z.object({
+      ...imageInputShape,
+      title: z.string().min(1).describe("Sent to Yoto as the uploaded file's name."),
+      autoConvert: z.boolean().optional().describe("Let Yoto auto-convert the image to its 16x16 icon format. Default false.")
+    }),
+    outputSchema: z.object({ mediaId: z.string(), url: z.string().optional() }),
+    summary: (output) => `Uploaded icon -- ${output.mediaId}.`,
+    handler: async (args) => {
+      const input = deps.mode === "cli" ? { imagePath: args.imagePath } : { imageUrl: args.imageUrl };
+      const image = await deps.resolveImage(input);
+      const icon = await uploadCustomIcon(deps.client, image.bytes, image.contentType, {
+        filename: args.title,
+        autoConvert: args.autoConvert
+      });
+      return { mediaId: icon.mediaId, url: icon.url };
+    }
+  };
+  return [yotoSearchIcons, yotoUploadIcon];
+}
+
+// ../../packages/core/dist/yoto/media.js
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function uploadAudio(client, source, options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? 750;
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  const loudnorm = options.loudnorm ?? false;
+  const now = options.now ?? (() => Date.now());
+  const sleep = options.sleep ?? defaultSleep;
+  const { upload } = await getUploadUrl(client, { filename: source.filename });
+  if (upload.uploadUrl) {
+    const putHeaders = { "Content-Type": source.contentType };
+    const putResponse = await client.fetchImpl(upload.uploadUrl, {
+      method: "PUT",
+      // `duplex: "half"` is required by fetch implementations (undici, the
+      // Workers runtime) to stream a body, but isn't in lib.dom's RequestInit
+      // type yet.
+      // biome-ignore lint/suspicious/noExplicitAny: streaming-body fetch option missing from lib.dom types.
+      ...{ duplex: "half" },
+      body: source.stream,
+      headers: putHeaders
+    });
+    if (!putResponse.ok) {
+      throw new YotoError(`Uploading audio to Yoto's storage failed (HTTP ${putResponse.status})`, {
+        code: "UPSTREAM_ERROR",
+        retryable: true,
+        status: putResponse.status
+      });
+    }
+  }
+  const deadline = now() + timeoutMs;
+  for (; ; ) {
+    const status = await getTranscodedStatus(client, upload.uploadId, loudnorm);
+    const sha = status.transcode.transcodedSha256;
+    if (sha) {
+      return { mediaRef: `yoto:#${sha}`, transcodedInfo: status.transcode.transcodedInfo ?? {} };
+    }
+    if (now() >= deadline) {
+      throw new YotoError("Yoto didn't finish transcoding the audio in time", {
+        code: "TRANSCODE_TIMEOUT",
+        retryable: true,
+        hint: "Try again, or upload a shorter/smaller file."
+      });
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+function bytesStartWith(bytes, offset, pattern) {
+  if (bytes.length < offset + pattern.length)
+    return false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (bytes[offset + i] !== pattern[i])
+      return false;
+  }
+  return true;
+}
+var ASCII = (text) => Array.from(text, (c) => c.charCodeAt(0));
+function sniffAudio(bytes, filename) {
+  if (bytesStartWith(bytes, 0, ASCII("ID3")))
+    return { valid: true, format: "mp3" };
+  if (bytes.length >= 2 && bytes[0] === 255 && ((bytes[1] ?? 0) & 224) === 224)
+    return { valid: true, format: "mp3" };
+  if (bytesStartWith(bytes, 4, ASCII("ftyp")))
+    return { valid: true, format: "m4a" };
+  if (bytesStartWith(bytes, 0, ASCII("RIFF")) && bytesStartWith(bytes, 8, ASCII("WAVE"))) {
+    return { valid: true, format: "wav" };
+  }
+  if (bytesStartWith(bytes, 0, ASCII("OggS")))
+    return { valid: true, format: "ogg" };
+  throw new YotoError(`Could not recognise${filename ? ` "${filename}"` : " this file"} as a supported audio format`, { code: "INVALID_AUDIO", hint: "Supported formats: MP3, M4A/AAC, WAV, OGG." });
+}
+function sniffImage(bytes, filename) {
+  if (bytesStartWith(bytes, 0, [137, 80, 78, 71, 13, 10, 26, 10])) {
+    return { valid: true, format: "png" };
+  }
+  if (bytesStartWith(bytes, 0, [255, 216, 255]))
+    return { valid: true, format: "jpeg" };
+  const head = new TextDecoder("utf-8", { fatal: false }).decode(bytes.slice(0, 256)).trimStart().toLowerCase();
+  if (head.startsWith("<?xml") || head.startsWith("<svg"))
+    return { valid: true, format: "svg" };
+  throw new YotoError(`Could not recognise${filename ? ` "${filename}"` : " this file"} as a supported image format`, { code: "INVALID_IMAGE", hint: "Supported formats: PNG, JPEG, SVG." });
+}
+
+// ../../packages/core/dist/tools/media.js
+var httpsUrl2 = z.string().url().refine((value) => value.startsWith("https://"), { message: "Must be an https:// URL." });
+function audioInputSchema(mode) {
+  return mode === "cli" ? z.object({
+    audioFilePath: z.string().min(1).describe("Absolute path to a local audio file (MP3, M4A/AAC, WAV, or OGG).")
+  }) : z.object({
+    audioUrl: httpsUrl2.describe("An https:// URL to an audio file (MP3, M4A/AAC, WAV, or OGG) -- this connector runs remotely, so give a link, not a file path.")
+  });
+}
+function toAudioInput(mode, args) {
+  return mode === "cli" ? { audioFilePath: args.audioFilePath } : { audioUrl: args.audioUrl };
+}
+function createMediaTools(deps) {
+  const yotoUploadAudio = {
+    name: "yoto_upload_audio",
+    title: "Upload audio to Yoto",
+    description: "Uploads an audio file to Yoto and waits for it to finish transcoding, returning a yoto:#<sha256> mediaRef usable as a track when creating or updating a card. " + (deps.mode === "cli" ? "Runs locally, so it takes a file path." : "This connector runs remotely, so it takes a link, not a file path."),
+    group: "media",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: audioInputSchema(deps.mode).extend({
+      loudnorm: z.boolean().optional().describe("Apply loudness normalisation. Default false.")
+    }),
+    outputSchema: z.object({
+      mediaRef: z.string(),
+      duration: z.number().optional(),
+      fileSize: z.number().optional(),
+      format: z.string().optional()
+    }),
+    summary: (output) => `Uploaded audio -- ${output.mediaRef}${output.duration ? ` (${output.duration}s)` : ""}.`,
+    handler: async (args) => {
+      const source = await deps.resolveAudio(toAudioInput(deps.mode, args));
+      const result = await uploadAudio(deps.client, source, { loudnorm: args.loudnorm });
+      return {
+        mediaRef: result.mediaRef,
+        duration: result.transcodedInfo.duration,
+        fileSize: result.transcodedInfo.fileSize,
+        format: result.transcodedInfo.format
+      };
+    }
+  };
+  const yotoAddTrack = {
+    name: "yoto_add_track",
+    title: "Add a track to a Yoto card",
+    description: "Uploads an audio file and appends it as a new chapter/track on an existing MYO card. " + (deps.mode === "cli" ? "Runs locally, so it takes a file path." : "This connector runs remotely, so it takes a link, not a file path."),
+    group: "media",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: audioInputSchema(deps.mode).extend({
+      cardId: cardIdSchema,
+      trackTitle: z.string().optional(),
+      iconRef: z.string().optional().describe("A yoto:#<mediaId> icon reference, e.g. from yoto_upload_icon.")
+    }),
+    outputSchema: z.object({ card: cardSchema }),
+    summary: (output) => `Added a track to "${output.card.title}" (${output.card.cardId}).`,
+    handler: async (args) => {
+      const source = await deps.resolveAudio(toAudioInput(deps.mode, args));
+      const uploaded = await uploadAudio(deps.client, source);
+      const existing = await getCard(deps.client, args.cardId);
+      const chapters = existing.content?.chapters ?? [];
+      const nextNumber = chapters.length + 1;
+      const key = String(nextNumber).padStart(2, "0");
+      const title = args.trackTitle ?? source.filename ?? `Track ${nextNumber}`;
+      const newChapter = {
+        key,
+        title,
+        overlayLabel: String(nextNumber),
+        ...args.iconRef ? { display: { icon16x16: args.iconRef } } : {},
+        tracks: [
+          {
+            key,
+            title,
+            trackUrl: uploaded.mediaRef,
+            type: "audio",
+            overlayLabel: String(nextNumber),
+            ...args.iconRef ? { display: { icon16x16: args.iconRef } } : {}
+          }
+        ]
+      };
+      const card = await upsertCard(deps.client, {
+        ...existing,
+        cardId: args.cardId,
+        content: { ...existing.content, chapters: [...chapters, newChapter] }
+      });
+      return { card };
+    }
+  };
+  return [yotoUploadAudio, yotoAddTrack];
+}
+
+// ../../packages/core/dist/tools/index.js
+function createTools(deps) {
+  return [
+    ...createAuthTools(deps),
+    ...createContentTools(deps),
+    ...createMediaTools(deps),
+    ...createIconTools(deps),
+    ...createDeviceTools(deps)
+  ];
+}
+var YOTO_SCOPES = [
+  "profile",
+  "offline_access",
+  "user:content:view",
+  "user:content:manage",
+  "user:icons:manage",
+  "family:library:view",
+  "family:devices:view"
+];
+z.object({
+  signedIn: z.boolean(),
+  mode: z.enum(["cli", "remote"]),
+  tokenStore: z.enum(["keychain", "file", "remote"]).optional(),
+  expiresAt: z.number().optional(),
+  scopes: z.array(z.string()).optional(),
+  hint: z.string().optional()
+});
+z.object({
+  url: z.string().optional(),
+  message: z.string()
+});
+
+// ../../packages/core/dist/logging.js
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var TOKEN_PATTERN = /eyJ[a-zA-Z0-9_-]{10,}(?:\.[a-zA-Z0-9_-]{10,}){0,2}|[a-zA-Z0-9_-]{32,}/g;
+function redact(input) {
+  return input.replace(TOKEN_PATTERN, "[redacted]");
+}
+function redactValue(value) {
+  if (typeof value === "string")
+    return redact(value);
+  return JSON.parse(redact(JSON.stringify(value)));
+}
+var NOOP_SINK = () => {
+};
+function createLogger(options = {}) {
+  const minLevel = options.level ?? "info";
+  const sink = options.sink ?? NOOP_SINK;
+  function write(level, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
+      return;
+    const safeMessage = redact(message);
+    const safeData = data === void 0 ? void 0 : redactValue(data);
+    sink({ level, message: safeMessage, data: safeData });
+  }
+  return {
+    debug: (message, data) => write("debug", message, data),
+    info: (message, data) => write("info", message, data),
+    warn: (message, data) => write("warn", message, data),
+    error: (message, data) => write("error", message, data)
+  };
+}
+var noopLogger = createLogger({ sink: NOOP_SINK });
+
+// ../../packages/core/dist/yoto/client.js
+var MAX_ATTEMPTS = 3;
+var RETRY_AFTER_CAP_MS = 3e4;
+var BACKOFF_BASE_MS = 300;
+var BACKOFF_CAP_MS = 8e3;
+function computeFullJitterDelayMs(attempt, options = {}) {
+  const base = options.base ?? BACKOFF_BASE_MS;
+  const cap = options.cap ?? BACKOFF_CAP_MS;
+  const random = options.random ?? Math.random;
+  const upperBound = Math.min(cap, base * 2 ** (attempt - 1));
+  return random() * upperBound;
+}
+function parseRetryAfterMs(value, now) {
+  if (!value)
+    return void 0;
+  const asSeconds = Number(value);
+  if (!Number.isNaN(asSeconds))
+    return Math.max(0, asSeconds * 1e3);
+  const asDate = Date.parse(value);
+  if (!Number.isNaN(asDate))
+    return Math.max(0, asDate - now());
+  return void 0;
+}
+var HINTS = {
+  AUTH_EXPIRED: "Run yoto_sign_in to refresh your Yoto session.",
+  FORBIDDEN_SCOPE: "This connection doesn't have the Yoto scope this action needs.",
+  RATE_LIMITED: "Yoto is rate-limiting requests right now; try again shortly.",
+  NOT_FOUND: "That Yoto resource wasn't found.",
+  UPSTREAM_ERROR: "Yoto's API returned an unexpected error."
+};
+function defaultSleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var YotoClient = class {
+  getToken;
+  fetchImpl;
+  baseUrl;
+  logger;
+  now;
+  sleepImpl;
+  constructor(options) {
+    this.getToken = options.getToken;
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    this.baseUrl = options.baseUrl ?? "https://api.yotoplay.com";
+    this.logger = options.logger ?? noopLogger;
+    this.now = options.now ?? (() => Date.now());
+    this.sleepImpl = options.sleep ?? defaultSleep2;
+  }
+  buildUrl(path, query) {
+    const url = new URL(path.startsWith("http") ? path : `${this.baseUrl}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0)
+          url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  async toUpstreamError(response, code) {
+    let detail = "";
+    try {
+      const text = await response.text();
+      if (text) {
+        try {
+          const parsed = JSON.parse(text);
+          detail = parsed.message ?? parsed.error ?? text;
+        } catch {
+          detail = text;
+        }
+      }
+    } catch {
+    }
+    const retryable = code === "RATE_LIMITED" || code === "UPSTREAM_ERROR";
+    return new YotoError(`Yoto API returned ${response.status}${detail ? `: ${detail}` : ""}`, {
+      code,
+      retryable,
+      status: response.status,
+      hint: HINTS[code]
+    });
+  }
+  async parseBody(response, schema, method, path) {
+    if (response.status === 204)
+      return void 0;
+    const text = await response.text();
+    let json;
+    try {
+      json = text ? JSON.parse(text) : void 0;
+    } catch (cause) {
+      throw new YotoError(`Yoto returned invalid JSON for ${method} ${path}`, {
+        code: "UPSTREAM_ERROR",
+        cause,
+        hint: "This may be a transient Yoto API issue -- try again."
+      });
+    }
+    if (!schema)
+      return json;
+    const result = schema.safeParse(json);
+    if (!result.success) {
+      throw new YotoError(`Yoto's response for ${method} ${path} didn't match the expected shape`, {
+        code: "UPSTREAM_ERROR",
+        cause: result.error,
+        hint: "Yoto may have changed their API response shape."
+      });
+    }
+    return result.data;
+  }
+  async request(options) {
+    const idempotent = options.idempotent ?? options.method === "GET";
+    const url = this.buildUrl(options.path, options.query);
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      let response;
+      try {
+        const token = await this.getToken();
+        const headers = {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/json",
+          ...options.headers
+        };
+        let body;
+        if (options.rawBody !== void 0) {
+          body = options.rawBody;
+          if (options.contentType)
+            headers["Content-Type"] = options.contentType;
+        } else if (options.body !== void 0) {
+          body = JSON.stringify(options.body);
+          headers["Content-Type"] = "application/json";
+        }
+        response = await this.fetchImpl(url, { method: options.method, headers, body });
+      } catch (cause) {
+        if (isYotoError(cause))
+          throw cause;
+        if (!idempotent || attempt >= MAX_ATTEMPTS) {
+          throw new YotoError(`Network request to Yoto failed: ${options.method} ${options.path}`, {
+            code: "UPSTREAM_ERROR",
+            retryable: true,
+            cause,
+            hint: "Check network connectivity and try again."
+          });
+        }
+        this.logger.warn("Yoto request failed, retrying", {
+          method: options.method,
+          path: options.path,
+          attempt
+        });
+        await this.sleepImpl(computeFullJitterDelayMs(attempt));
+        continue;
+      }
+      if (response.ok) {
+        return this.parseBody(response, options.schema, options.method, options.path);
+      }
+      if (response.status === 429) {
+        if (!idempotent || attempt >= MAX_ATTEMPTS) {
+          throw await this.toUpstreamError(response, "RATE_LIMITED");
+        }
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"), this.now);
+        await this.sleepImpl(Math.min(retryAfterMs ?? computeFullJitterDelayMs(attempt), RETRY_AFTER_CAP_MS));
+        continue;
+      }
+      if (response.status >= 500) {
+        if (!idempotent || attempt >= MAX_ATTEMPTS) {
+          throw await this.toUpstreamError(response, "UPSTREAM_ERROR");
+        }
+        await this.sleepImpl(computeFullJitterDelayMs(attempt));
+        continue;
+      }
+      if (response.status === 401)
+        throw await this.toUpstreamError(response, "AUTH_EXPIRED");
+      if (response.status === 403)
+        throw await this.toUpstreamError(response, "FORBIDDEN_SCOPE");
+      if (response.status === 404)
+        throw await this.toUpstreamError(response, "NOT_FOUND");
+      throw await this.toUpstreamError(response, "UPSTREAM_ERROR");
+    }
+    throw new YotoError(`Request to Yoto failed after ${MAX_ATTEMPTS} attempts`, {
+      code: "UPSTREAM_ERROR"
+    });
+  }
+  /**
+   * Generic cursor-pagination helper. None of the 14 tools' endpoints
+   * currently paginate (Yoto returns full collections for content/devices/
+   * icons), but this keeps the shape ready for the day one does, and is
+   * exercised directly in tests.
+   */
+  async *paginate(fetchPage) {
+    let cursor;
+    do {
+      const page = await fetchPage(cursor);
+      for (const item of page.items)
+        yield item;
+      cursor = page.nextCursor;
+    } while (cursor);
+  }
+};
+
+// ../../packages/core/dist/index.js
+function registerAll(server, deps) {
+  const iconBaseUrl = deps.iconBaseUrl ?? DEFAULT_ICON_BASE_URL;
+  for (const spec of createTools(deps)) {
+    defineTool(server, spec, { logger: deps.logger, iconBaseUrl });
+  }
+  registerResources(server, deps);
+  registerPrompts(server);
+}
+function createServer(deps, options) {
+  const iconBaseUrl = deps.iconBaseUrl ?? options.iconBaseUrl ?? DEFAULT_ICON_BASE_URL;
+  const server = new McpServer({
+    name: options.name,
+    title: options.title ?? "Yoto",
+    version: options.version,
+    icons: [{ src: `${iconBaseUrl}/server.png`, mimeType: "image/png", sizes: ["64x64"] }],
+    websiteUrl: options.websiteUrl ?? "https://github.com/danpillay87/mcp-yoto"
+  }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+  registerAll(server, { ...deps, iconBaseUrl });
+  return server;
+}
+var LoopbackError = class extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.name = "LoopbackError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+var SUCCESS_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>Signed in to Yoto</title></head><body style="font-family:system-ui,sans-serif;padding:3rem;max-width:32rem;margin:0 auto"><h1>You're signed in \u2014 you can close this tab.</h1><p>Head back to your AI client -- mcp-yoto is ready.</p></body></html>`;
+function failureHtml(message) {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>Sign-in failed</title></head><body style="font-family:system-ui,sans-serif;padding:3rem;max-width:32rem;margin:0 auto"><h1>Sign-in failed</h1><p>${escapeHtml(message)}</p></body></html>`;
+}
+var HTML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+}
+function sendHtml(res, status, body) {
+  res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+  res.end(body);
+}
+function awaitLoopbackCallback(options) {
+  const timeoutMs = options.timeoutMs ?? 3e5;
+  const setTimeoutImpl = options.setTimeoutImpl ?? setTimeout;
+  const clearTimeoutImpl = options.clearTimeoutImpl ?? clearTimeout;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    const server = createServer$1(handleRequest);
+    function finish(action) {
+      if (settled) return;
+      settled = true;
+      if (timer !== void 0) clearTimeoutImpl(timer);
+      server.close();
+      action();
+    }
+    function handleRequest(req, res) {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${options.port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const upstreamError = url.searchParams.get("error");
+      if (upstreamError) {
+        sendHtml(res, 200, failureHtml(`Yoto returned an error: ${upstreamError}`));
+        finish(
+          () => reject(
+            new LoopbackError(
+              `Yoto returned an error during sign-in: ${upstreamError}`,
+              "CALLBACK_ERROR"
+            )
+          )
+        );
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      if (!code || state !== options.expectedState) {
+        sendHtml(res, 400, failureHtml("This sign-in link is stale or was tampered with."));
+        finish(
+          () => reject(
+            new LoopbackError(
+              "Sign-in callback state did not match -- stale or invalid attempt.",
+              "CALLBACK_ERROR",
+              "Run yoto_sign_in again."
+            )
+          )
+        );
+        return;
+      }
+      sendHtml(res, 200, SUCCESS_HTML);
+      finish(() => resolve({ code }));
+    }
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        finish(
+          () => reject(
+            new LoopbackError(
+              `Port ${options.port} is already in use.`,
+              "PORT_IN_USE",
+              "Set YOTO_REDIRECT_PORT to a free port that's also registered at Yoto, or close whatever's using it."
+            )
+          )
+        );
+        return;
+      }
+      finish(() => reject(new LoopbackError(err.message, "CALLBACK_ERROR")));
+    });
+    server.listen(options.port, "127.0.0.1", () => {
+      timer = setTimeoutImpl(() => {
+        finish(
+          () => reject(
+            new LoopbackError(
+              "Timed out waiting for the Yoto sign-in callback.",
+              "AUTH_TIMEOUT",
+              "Run yoto_sign_in again."
+            )
+          )
+        );
+      }, timeoutMs);
+    });
+  });
+}
+function openInBrowser(url) {
+  try {
+    let child;
+    if (process.platform === "win32") {
+      child = spawn("rundll32.exe", ["url.dll,FileProtocolHandler", url], {
+        shell: false,
+        detached: true,
+        stdio: "ignore"
+      });
+    } else if (process.platform === "darwin") {
+      child = spawn("open", [url], { shell: false, detached: true, stdio: "ignore" });
+    } else {
+      child = spawn("xdg-open", [url], { shell: false, detached: true, stdio: "ignore" });
+    }
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function codeChallengeFromVerifier(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function createPkcePair() {
+  const verifier = randomBytes(32).toString("base64url");
+  return { verifier, challenge: codeChallengeFromVerifier(verifier) };
+}
+function createState() {
+  return randomBytes(16).toString("base64url");
+}
+
+// src/auth/token-exchange.ts
+async function postTokenRequest(fetchImpl, tokenUrl, params) {
+  const response = await fetchImpl(tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params)
+  });
+  if (response.ok) {
+    return { ok: true, data: await response.json() };
+  }
+  let error;
+  try {
+    error = await response.json();
+  } catch {
+  }
+  return { ok: false, status: response.status, error };
+}
+
+// src/auth/session.ts
+var REFRESH_SKEW_MS = 10 * 60 * 1e3;
+function decodeJwtExpMs(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const payloadJson = Buffer.from(parts[1] ?? "", "base64url").toString("utf-8");
+    const payload = JSON.parse(payloadJson);
+    return typeof payload.exp === "number" ? payload.exp * 1e3 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var Session = class {
+  config;
+  tokenStore;
+  fetchImpl;
+  now;
+  inFlightRefresh;
+  constructor(options) {
+    this.config = options.config;
+    this.tokenStore = options.tokenStore;
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    this.now = options.now ?? (() => Date.now());
+  }
+  /**
+   * Returns a live access token, refreshing first if the current one is
+   * within 10 minutes of expiry (or the store carries no readable expiry
+   * at all, which fails safe by treating it as due for refresh).
+   */
+  async getAccessToken() {
+    const stored = await this.tokenStore.load();
+    if (!stored) {
+      throw new YotoError("Not signed in to Yoto.", {
+        code: "NOT_AUTHENTICATED",
+        hint: "Run yoto_sign_in."
+      });
+    }
+    const expiresAt = decodeJwtExpMs(stored.accessToken) ?? stored.expiresAt;
+    const now = this.now();
+    if (expiresAt !== void 0 && expiresAt - REFRESH_SKEW_MS > now) {
+      return stored.accessToken;
+    }
+    if (!stored.refreshToken) {
+      if (expiresAt !== void 0 && expiresAt > now) return stored.accessToken;
+      throw new YotoError("Your Yoto session has expired.", {
+        code: "AUTH_EXPIRED",
+        hint: "Run yoto_sign_in."
+      });
+    }
+    return this.refresh(stored.refreshToken);
+  }
+  /** Single-flight: concurrent callers share the one in-flight refresh instead of each starting their own. */
+  refresh(refreshToken) {
+    if (!this.inFlightRefresh) {
+      this.inFlightRefresh = this.doRefresh(refreshToken).finally(() => {
+        this.inFlightRefresh = void 0;
+      });
+    }
+    return this.inFlightRefresh;
+  }
+  async doRefresh(refreshToken) {
+    const result = await postTokenRequest(this.fetchImpl, `${this.config.authBase}/oauth/token`, {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.config.clientId
+    });
+    if (!result.ok) {
+      if (result.error?.error === "invalid_grant") {
+        await this.tokenStore.clear();
+        throw new YotoError("Yoto rejected the stored refresh token.", {
+          code: "AUTH_EXPIRED",
+          hint: "Run yoto_sign_in."
+        });
+      }
+      throw new YotoError(`Yoto token refresh failed (HTTP ${result.status}).`, {
+        code: "UPSTREAM_ERROR",
+        retryable: true,
+        status: result.status
+      });
+    }
+    const data = result.data;
+    const newTokens = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token ?? refreshToken,
+      expiresAt: data.expires_in !== void 0 ? this.now() + data.expires_in * 1e3 : void 0,
+      scope: data.scope
+    };
+    await this.tokenStore.save(newTokens);
+    return newTokens.accessToken;
+  }
+};
+var SERVICE = "mcp-yoto";
+var KeyringStore = class {
+  constructor(account) {
+    this.account = account;
+  }
+  account;
+  kind = "keychain";
+  async entry() {
+    const { AsyncEntry } = await import('@napi-rs/keyring');
+    return new AsyncEntry(SERVICE, this.account);
+  }
+  async load() {
+    const entry = await this.entry();
+    const raw = await entry.getPassword();
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async save(tokens) {
+    const entry = await this.entry();
+    await entry.setPassword(JSON.stringify(tokens));
+  }
+  async clear() {
+    const entry = await this.entry();
+    await entry.deletePassword();
+  }
+};
+function defaultTokenFilePath() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    return join(appData, "mcp-yoto", "tokens.json");
+  }
+  return join(homedir(), ".config", "mcp-yoto", "tokens.json");
+}
+var FileStore = class {
+  kind = "file";
+  filePath;
+  constructor(filePath = defaultTokenFilePath()) {
+    this.filePath = filePath;
+  }
+  async load() {
+    const primary = await this.readFrom(this.filePath);
+    if (primary) return primary;
+    return this.readFrom(`${this.filePath}.last-good`);
+  }
+  async readFrom(path) {
+    let raw;
+    try {
+      raw = await readFile(path, "utf-8");
+    } catch {
+      return void 0;
+    }
+    const stripped = raw.replace(/^/, "");
+    try {
+      return JSON.parse(stripped);
+    } catch {
+      return void 0;
+    }
+  }
+  async save(tokens) {
+    await mkdir(dirname(this.filePath), { recursive: true });
+    try {
+      await copyFile(this.filePath, `${this.filePath}.last-good`);
+    } catch {
+    }
+    const tmp = `${this.filePath}.tmp`;
+    await writeFile(tmp, JSON.stringify(tokens, null, 2), "utf-8");
+    await rename(tmp, this.filePath);
+    if (process.platform !== "win32") {
+      await chmod(this.filePath, 384);
+    }
+  }
+  async clear() {
+    for (const path of [this.filePath, `${this.filePath}.last-good`, `${this.filePath}.tmp`]) {
+      try {
+        await rm(path);
+      } catch {
+      }
+    }
+  }
+};
+async function createTokenStore(options) {
+  if (options.fileOverride) {
+    return new FileStore(options.fileOverride);
+  }
+  try {
+    const keyring = new KeyringStore(options.account);
+    await keyring.load();
+    return keyring;
+  } catch (error) {
+    const filePath = defaultTokenFilePath();
+    options.logger.warn(
+      `System keychain unavailable -- falling back to a local file at ${filePath} (0600 permissions on macOS/Linux; scoped to your Windows user profile).`,
+      { error: error instanceof Error ? error.message : String(error) }
+    );
+    return new FileStore(filePath);
+  }
+}
+
+// src/auth/adapter.ts
+function redirectUri(port) {
+  return `http://127.0.0.1:${port}/callback`;
+}
+function loopbackErrorToYotoError(error) {
+  if (error instanceof LoopbackError) {
+    if (error.code === "PORT_IN_USE") {
+      return new YotoError(error.message, { code: "PORT_IN_USE", hint: error.hint, cause: error });
+    }
+    if (error.code === "AUTH_TIMEOUT") {
+      return new YotoError(error.message, { code: "VALIDATION", hint: error.hint, cause: error });
+    }
+    return new YotoError(error.message, { code: "UPSTREAM_ERROR", hint: error.hint, cause: error });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new YotoError(message, { code: "UPSTREAM_ERROR", cause: error });
+}
+async function createCliAuthAdapter(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const now = options.now ?? (() => Date.now());
+  const tokenStore = await createTokenStore({
+    account: options.config.clientId,
+    logger: options.logger,
+    fileOverride: options.config.tokenFileOverride
+  });
+  const session = new Session({
+    config: { clientId: options.config.clientId, authBase: options.config.authBase },
+    tokenStore,
+    fetchImpl,
+    now
+  });
+  async function signIn(opts) {
+    const { verifier, challenge } = createPkcePair();
+    const state = createState();
+    const port = options.config.redirectPort;
+    const authorizeUrl = new URL(`${options.config.authBase}/authorize`);
+    authorizeUrl.searchParams.set("audience", options.config.audience);
+    authorizeUrl.searchParams.set("scope", YOTO_SCOPES.join(" "));
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("client_id", options.config.clientId);
+    authorizeUrl.searchParams.set("code_challenge", challenge);
+    authorizeUrl.searchParams.set("code_challenge_method", "S256");
+    authorizeUrl.searchParams.set("redirect_uri", redirectUri(port));
+    authorizeUrl.searchParams.set("state", state);
+    const url = authorizeUrl.toString();
+    opts?.onAuthorizeUrl?.(url);
+    const callbackPromise = awaitLoopbackCallback({ port, expectedState: state });
+    const shouldOpenBrowser = (opts?.openBrowser ?? true) && !options.config.noBrowser;
+    if (shouldOpenBrowser) openInBrowser(url);
+    let code;
+    try {
+      ({ code } = await callbackPromise);
+    } catch (error) {
+      throw loopbackErrorToYotoError(error);
+    }
+    const result = await postTokenRequest(fetchImpl, `${options.config.authBase}/oauth/token`, {
+      grant_type: "authorization_code",
+      client_id: options.config.clientId,
+      code,
+      code_verifier: verifier,
+      redirect_uri: redirectUri(port)
+    });
+    if (!result.ok) {
+      throw new YotoError(
+        `Yoto rejected the sign-in code (HTTP ${result.status}${result.error?.error ? `: ${result.error.error}` : ""}).`,
+        { code: "UPSTREAM_ERROR", status: result.status }
+      );
+    }
+    await tokenStore.save({
+      accessToken: result.data.access_token,
+      refreshToken: result.data.refresh_token,
+      expiresAt: result.data.expires_in !== void 0 ? now() + result.data.expires_in * 1e3 : void 0,
+      scope: result.data.scope ?? YOTO_SCOPES.join(" ")
+    });
+    return { url, message: "Signed in to Yoto." };
+  }
+  async function signOut() {
+    await tokenStore.clear();
+  }
+  return {
+    mode: "cli",
+    tokenStore,
+    async getAccessToken() {
+      return session.getAccessToken();
+    },
+    async status() {
+      const stored = await tokenStore.load();
+      if (!stored) {
+        return {
+          signedIn: false,
+          mode: "cli",
+          tokenStore: tokenStore.kind,
+          hint: "Run yoto_sign_in to connect your Yoto account."
+        };
+      }
+      const expiresAt = decodeJwtExpMs(stored.accessToken) ?? stored.expiresAt;
+      return {
+        signedIn: true,
+        mode: "cli",
+        tokenStore: tokenStore.kind,
+        expiresAt,
+        scopes: stored.scope ? stored.scope.split(" ") : void 0
+      };
+    },
+    signIn,
+    signOut
+  };
+}
+
+// src/config.ts
+var DEFAULT_CLIENT_ID = "xl4YsMpHEMnn7ubVhsRu8NhBwfUFPf8J";
+var YOTO_AUTH_BASE = "https://login.yotoplay.com";
+var AUDIENCE = "https://api.yotoplay.com";
+var DEFAULT_REDIRECT_PORT = 8791;
+var DEFAULT_ICON_BASE_URL2 = "https://raw.githubusercontent.com/danpillay87/mcp-yoto/main/apps/worker/public/icons";
+function parsePort(raw, fallback) {
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(
+      `YOTO_REDIRECT_PORT must be an integer between 1 and 65535, got ${JSON.stringify(raw)}.`
+    );
+  }
+  return parsed;
+}
+function parseLogLevel(raw) {
+  return raw === "debug" || raw === "warn" || raw === "error" ? raw : "info";
+}
+function parseBoolFlag(raw) {
+  return raw === "1" || raw?.toLowerCase() === "true";
+}
+function loadConfig(env = process.env) {
+  return {
+    clientId: env.YOTO_CLIENT_ID || DEFAULT_CLIENT_ID,
+    authBase: YOTO_AUTH_BASE,
+    audience: AUDIENCE,
+    redirectPort: parsePort(env.YOTO_REDIRECT_PORT, DEFAULT_REDIRECT_PORT),
+    noBrowser: parseBoolFlag(env.YOTO_NO_BROWSER),
+    logLevel: parseLogLevel(env.LOG_LEVEL),
+    iconBaseUrl: env.MCP_YOTO_ICON_BASE || DEFAULT_ICON_BASE_URL2,
+    scope: YOTO_SCOPES.join(" "),
+    tokenFileOverride: env.MCP_YOTO_TOKEN_FILE || void 0
+  };
+}
+var MAX_AUDIO_BYTES = 500 * 1024 * 1024;
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var SNIFF_BYTES = 4096;
+function expandHome(rawPath) {
+  if (rawPath === "~") return homedir();
+  if (rawPath.startsWith("~/") || rawPath.startsWith("~\\")) {
+    return resolve(homedir(), rawPath.slice(2));
+  }
+  return rawPath;
+}
+function toAbsolutePath(rawPath) {
+  const expanded = expandHome(rawPath);
+  if (expanded.startsWith("\\\\") || isAbsolute(expanded)) return expanded;
+  return resolve(process.cwd(), expanded);
+}
+async function readHead(path, length) {
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+async function statOrValidationError(path, label) {
+  let stats;
+  try {
+    stats = await stat(path);
+  } catch (error) {
+    throw new YotoError(`Could not find the ${label} at "${path}".`, {
+      code: "VALIDATION",
+      cause: error,
+      hint: "Check the path and try again."
+    });
+  }
+  if (!stats.isFile()) {
+    throw new YotoError(`"${path}" is not a file.`, { code: "VALIDATION" });
+  }
+  return { size: stats.size };
+}
+function audioContentType(format) {
+  switch (format) {
+    case "mp3":
+      return "audio/mpeg";
+    case "m4a":
+      return "audio/mp4";
+    case "wav":
+      return "audio/wav";
+    case "ogg":
+      return "audio/ogg";
+    default:
+      return "application/octet-stream";
+  }
+}
+function imageContentType(format) {
+  switch (format) {
+    case "png":
+      return "image/png";
+    case "jpeg":
+      return "image/jpeg";
+    case "svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function resolveAudio(input) {
+  if ("audioUrl" in input) {
+    throw new YotoError("This CLI reads local files -- pass audioFilePath, not audioUrl.", {
+      code: "VALIDATION",
+      hint: "audioUrl is for the remote (paste-a-link) connector only."
+    });
+  }
+  const path = toAbsolutePath(input.audioFilePath);
+  const { size } = await statOrValidationError(path, "audio file");
+  if (size > MAX_AUDIO_BYTES) {
+    throw new YotoError(
+      `"${path}" is ${(size / (1024 * 1024)).toFixed(1)} MB, over the 500 MB limit.`,
+      {
+        code: "VALIDATION"
+      }
+    );
+  }
+  const head = await readHead(path, SNIFF_BYTES);
+  const sniffed = sniffAudio(head, basename(path));
+  const stream = Readable.toWeb(createReadStream(path));
+  return {
+    stream,
+    size,
+    contentType: audioContentType(sniffed.format),
+    filename: basename(path)
+  };
+}
+async function resolveImage(input) {
+  if ("imageUrl" in input) {
+    throw new YotoError("This CLI reads local files -- pass imagePath, not imageUrl.", {
+      code: "VALIDATION",
+      hint: "imageUrl is for the remote (paste-a-link) connector only."
+    });
+  }
+  const path = toAbsolutePath(input.imagePath);
+  const { size } = await statOrValidationError(path, "image file");
+  if (size > MAX_IMAGE_BYTES) {
+    throw new YotoError(`"${path}" is over the 5 MB icon limit.`, { code: "VALIDATION" });
+  }
+  const buffer = await readFile(path);
+  const bytes = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  );
+  const sniffed = sniffImage(bytes, basename(path));
+  return { bytes, contentType: imageContentType(sniffed.format), filename: basename(path) };
+}
+
+// src/server.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function createCliServer(options) {
+  return createServer(
+    {
+      auth: options.auth,
+      client: options.client,
+      logger: options.logger,
+      iconBaseUrl: options.iconBaseUrl,
+      resolveAudio,
+      resolveImage,
+      mode: "cli"
+    },
+    {
+      name: "mcp-yoto",
+      version,
+      title: "Yoto (Works with Yoto)",
+      iconBaseUrl: options.iconBaseUrl,
+      websiteUrl: "https://github.com/danpillay87/mcp-yoto"
+    }
+  );
+}
+async function runStdioServer(options) {
+  const server = createCliServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/main.ts
+var require3 = createRequire(import.meta.url);
+var { version: version2 } = require3("../package.json");
+var HELP_TEXT = `mcp-yoto ${version2} -- MCP server for Yoto (cards, tracks, icons, devices)
+
+Usage:
+  npx mcp-yoto              Run the MCP server over stdio (for MCP clients)
+  npx mcp-yoto login        Sign in to Yoto (opens your browser)
+  npx mcp-yoto logout       Remove the locally stored Yoto credential
+  npx mcp-yoto status       Print sign-in status as JSON (to stdout)
+  npx mcp-yoto --version    Print the installed version
+  npx mcp-yoto --help       Show this help
+
+Environment variables:
+  YOTO_CLIENT_ID       Override the Yoto dev-app client id
+  YOTO_REDIRECT_PORT    Loopback port used during sign-in (default 8791;
+                         must match the redirect URI registered at Yoto)
+  YOTO_NO_BROWSER        Set to 1 to print the sign-in URL instead of
+                         opening a browser automatically
+  LOG_LEVEL              debug | info | warn | error (default info)
+  MCP_YOTO_ICON_BASE     Base URL tool icons are served from
+
+Your Yoto credential is stored in your OS keychain when available, or in a
+local file otherwise (run "status" to see which). Nothing is ever printed
+to stdout except JSON-RPC frames (default mode) or the "status" JSON.
+`;
+function stderrLogSink(line) {
+  const suffix = line.data ? ` ${JSON.stringify(line.data)}` : "";
+  process.stderr.write(`[mcp-yoto] ${line.level}: ${line.message}${suffix}
+`);
+}
+async function main(argv = process.argv.slice(2)) {
+  const [command] = argv;
+  if (command === "--version" || command === "-v") {
+    console.error(version2);
+    return;
+  }
+  if (command === "--help" || command === "-h") {
+    console.error(HELP_TEXT);
+    return;
+  }
+  const config = loadConfig();
+  const logLevel = config.logLevel;
+  const logger = createLogger({ level: logLevel, sink: stderrLogSink });
+  const auth = await createCliAuthAdapter({ config, logger });
+  const client = new YotoClient({
+    getToken: () => auth.getAccessToken(),
+    baseUrl: config.audience,
+    logger
+  });
+  if (command === "login") {
+    if (!auth.signIn) throw new Error("Sign-in isn't available on this connection.");
+    const result = await auth.signIn({
+      openBrowser: !config.noBrowser,
+      // Fires synchronously as soon as the authorize URL is built, well
+      // before the loopback callback ever arrives -- see adapter.ts. With
+      // YOTO_NO_BROWSER=1 (or no default handler registered) this is the
+      // only place the user ever sees the link.
+      onAuthorizeUrl: (url) => {
+        process.stderr.write(
+          "Sign in to Yoto in your browser. If it did not open, use this link:\n"
+        );
+        process.stderr.write(`${url}
+`);
+      }
+    });
+    if (result.url) process.stderr.write(`Sign-in URL: ${result.url}
+`);
+    process.stderr.write(`${result.message}
+`);
+    return;
+  }
+  if (command === "logout") {
+    if (!auth.signOut) throw new Error("Sign-out isn't available on this connection.");
+    await auth.signOut();
+    process.stderr.write("Signed out of Yoto.\n");
+    return;
+  }
+  if (command === "status") {
+    const status = await auth.status();
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  if (command) {
+    process.stderr.write(`Unknown command: ${command}
+
+${HELP_TEXT}`);
+    process.exitCode = 1;
+    return;
+  }
+  await runStdioServer({ auth, client, logger, iconBaseUrl: config.iconBaseUrl });
+}
+
+export { DEFAULT_CLIENT_ID, main };
+//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map