@cmo-so/mcp 0.2.0 → 0.4.0

package/dist/cmo-mcp.mjs

@@ -7199,7 +7199,7 @@ var require_dist = __commonJS({
 // package.json
 var package_default = {
   name: "@cmo-so/cli",
-  version: "0.2.0",
+  version: "0.4.0",
   description: "CMO.so on the command line: your websites, ideas, blog posts, LinkedIn queue and results, plus a local MCP server for Claude Desktop, Cursor and other MCP clients.",
   type: "module",
   license: "MIT",
@@ -7530,7 +7530,15 @@ function dataUrl(type, bytes) {
 }
 
 // ../../packages/api-client/src/domains.ts
-var MEMORY_CHANNELS = ["general", "blog", "linkedin", "facebook"];
+var MEMORY_CHANNELS = [
+  "general",
+  "blog",
+  "linkedin",
+  "facebook",
+  "instagram",
+  "google_business",
+  "youtube"
+];
 function addWebsite(api2, url) {
   return api2.request("/v1/domains", {
     method: "POST",
@@ -7649,8 +7657,15 @@ function domainApi(api2, domain) {
     approveSocial: (id) => post(`${base}/social/${id}/approve`),
     skipSocial: (id) => post(`${base}/social/${id}/skip`),
     /** Post it on LinkedIn now, not at the next posting time (even while posting is paused). */
-    publishSocialNow: (id) => post(`${base}/social/${id}/publish`),
+    /** Post it now. `background`: the reply comes at once (status "publishing") and it goes out behind the
+     *  scenes (a notice when it's out); 409 `picture_busy` while its picture is being made. */
+    publishSocialNow: (id, opts = {}) => post(
+      `${base}/social/${id}/publish`,
+      opts.background ? { background: true } : void 0
+    ),
     /** Take a posted LinkedIn post down (its likes and comments go with it). */
+    /** How a posted Instagram post is doing (read from Instagram, kept 15 minutes; `refresh` reads again). */
+    socialInsights: (id, refresh = false) => api2.request(`${base}/social/${id}/insights${refresh ? "?refresh=true" : ""}`),
     deletePostedSocial: (id) => api2.request(`${base}/social/${id}/published`, { method: "DELETE" }),
     /** Change a posted LinkedIn post and put it up again: the old one comes down, the new text goes out now. */
     republishSocial: (id, socialCopy) => post(`${base}/social/${id}/republish`, socialCopy ? { social_copy: socialCopy } : {}),
@@ -7686,10 +7701,10 @@ function domainApi(api2, domain) {
     /** The template library, searchable. */
     socialTemplates: (search = "") => api2.request(`${base}/social/templates?search=${encodeURIComponent(search)}`),
     socialTemplatePreview: (key) => api2.request(`${base}/social/templates/${encodeURIComponent(key)}/preview`),
-    socialSetupTemplates: (keys2, writing) => api2.request(`${base}/social/setup/templates`, {
+    socialSetupTemplates: (keys2, writing2) => api2.request(`${base}/social/setup/templates`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ keys: keys2, writing })
+      body: JSON.stringify({ keys: keys2, writing: writing2 })
     }),
     socialSetupSchedule: (schedule) => api2.request(`${base}/social/setup/schedule`, {
       method: "PUT",
@@ -7731,6 +7746,49 @@ function domainApi(api2, domain) {
       }
     ),
     disconnectFacebook: (connectionId) => api2.request(`${base}/social/facebook/${connectionId}`, { method: "DELETE" }),
+    /** Instagram connects through the Facebook sign-in (the accounts linked to your Pages): the same link;
+     *  back with ?facebook=connected, then `channels` says whether an Instagram account was found. */
+    connectInstagram: (returnTo = "close") => post(`${base}/social/instagram/connect`, { return_to: returnTo }),
+    /** Your Instagram accounts here (each with the Facebook Page it posts through), and the chosen one. */
+    instagramAccounts: () => api2.request(`${base}/social/instagram/accounts`),
+    chooseInstagramAccount: (connectionId) => api2.request(
+      `${base}/social/instagram/account`,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ connection_id: connectionId })
+      }
+    ),
+    disconnectInstagram: (connectionId) => api2.request(`${base}/social/instagram/${connectionId}`, { method: "DELETE" }),
+    /** A Google sign-in link for this website's Google Business Profile; back with ?google_business=connected
+     *  (or none / error&message=…). Every profile the account can post to is saved; this website's is picked. */
+    connectGoogleBusiness: (returnTo = "close") => post(`${base}/social/google_business/connect`, {
+      return_to: returnTo
+    }),
+    /** Your Google Business profiles here (name, address, website), and the one this website posts to. */
+    googleBusinessLocations: () => api2.request(`${base}/social/google_business/locations`),
+    chooseGoogleBusinessLocation: (connectionId) => put(
+      `${base}/social/google_business/location`,
+      { connection_id: connectionId }
+    ),
+    /** How the Google Business Profile is doing: the last 28 days and the 28 before (Google lags 2-3 days). */
+    googleBusinessPerformance: (refresh = false) => api2.request(`${base}/social/google_business/performance${refresh ? "?refresh=true" : ""}`),
+    disconnectGoogleBusiness: (connectionId) => api2.request(`${base}/social/google_business/${connectionId}`, { method: "DELETE" }),
+    /** A Google sign-in link for this website's YouTube channel (docs/prd/youtube.md §7); back with ?youtube=connected
+     *  (or none when the Google account has no channel, error&message=…). */
+    connectYouTube: (returnTo = "close") => post(`${base}/social/youtube/connect`, { return_to: returnTo }),
+    /** Your YouTube channels here (name, @handle, picture, subscribers), and the one this website posts to. */
+    youtubeChannels: () => api2.request(
+      `${base}/social/youtube/channels`
+    ),
+    chooseYouTubeChannel: (connectionId) => put(
+      `${base}/social/youtube/channel`,
+      {
+        connection_id: connectionId
+      }
+    ),
+    /** Disconnect: the token is deleted and Google's access revoked (YouTube's policy). */
+    disconnectYouTube: (connectionId) => api2.request(`${base}/social/youtube/${connectionId}`, { method: "DELETE" }),
     /** One channel's own pause switch (pauseSocial / resumeSocial hold every channel). */
     setChannelPaused: (channel, paused) => post(`${base}/social/channels/${channel}/${paused ? "pause" : "resume"}`),
     /** How often one channel posts. */
@@ -7740,14 +7798,56 @@ function domainApi(api2, domain) {
     ),
     /** Start a new picture for the post in the background (one AI generation); `replace` stops the one
      * already running; `instruction` (up to 300 characters) steers it: "gold border, our logo". */
+    // `mode: "edit"` changes the post's current picture as `instruction` says. Another picture
+    // being made here: this one waits its turn (status queued).
+    // `count: 4` makes a set of 4 pictures from one storyboard (one AI generation), with words on each in
+    // `textEffect` (an id from socialTextEffects; omit = Maggie picks).
     regenerateSocialImage: (id, opts = {}) => post(`${base}/social/${id}/image/regenerate`, {
+      ...opts.style ? { style: opts.style } : {},
       ...opts.replace ? { replace: true } : {},
+      ...opts.instruction?.trim() ? { instruction: opts.instruction.trim() } : {},
+      ...opts.mode === "edit" ? { mode: "edit" } : {},
+      ...opts.count && opts.count > 1 ? { count: opts.count } : {},
+      ...opts.textEffect ? { text_effect: opts.textEffect } : {}
+    }),
+    /** Change a picture Maggie made without a new one (free): the words on each picture, its style, its text
+     *  style, the order of a set, or drop pictures from it. `words` follow the new order when `order` is given. */
+    editSocialPicture: (id, changes) => api2.request(`${base}/social/${id}/picture`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(changes)
+    }),
+    /** A title and a line on your own photo(s) in your look (Maggie plans the words; no AI picture, free). */
+    wordsOnPhoto: (id, style = "real_photo") => post(`${base}/social/${id}/picture/words`, { style }),
+    /** The brand's picture look (made the first time it's asked for). */
+    socialLook: () => api2.request(`${base}/social/look`),
+    updateSocialLook: (changes) => put(`${base}/social/look`, changes),
+    /** Maggie looks again and suggests a new look (one AI generation). */
+    suggestSocialLook: () => post(`${base}/social/look/suggest`, {}),
+    /** A sample picture of a style in the brand's look: a data: URL. */
+    socialLookSample: (style) => api2.request(`${base}/social/look/sample?style=${encodeURIComponent(style)}`),
+    /** The text effects for the words on a set of pictures, each with a sample picture. */
+    socialTextEffects: () => api2.request(`${base}/social/text-effects`),
+    /** Your own photo (base64 JPEG) as the post's picture: no AI, no charge; only before it goes out.
+     *  With `instruction`, Maggie changes the photo as it says, in the background (one AI generation). */
+    uploadSocialPhoto: (id, photo, opts = {}) => post(`${base}/social/${id}/image`, {
+      photo,
       ...opts.instruction?.trim() ? { instruction: opts.instruction.trim() } : {}
     }),
-    /** Your own photo (base64 JPEG) as the post's picture: no AI, no charge; only before it goes out. */
-    uploadSocialPhoto: (id, photo) => post(`${base}/social/${id}/image`, { photo }),
-    /** Stop the picture being made (it's thrown away). */
-    stopSocialImage: () => api2.request(`${base}/social/image-job`, { method: "DELETE" }),
+    /** A new picture for every post here without one (or these), one after another in the background. */
+    fillSocialImages: (opts = {}) => post(
+      `${base}/social/images/fill`,
+      {
+        ...opts.item_ids ? { item_ids: opts.item_ids } : {},
+        ...opts.instruction?.trim() ? { instruction: opts.instruction.trim() } : {},
+        ...opts.count && opts.count > 1 ? { count: opts.count } : {},
+        ...opts.textEffect ? { text_effect: opts.textEffect } : {}
+      }
+    ),
+    /** Stop the picture being made (it's thrown away; the next in line starts). `all` empties the line too. */
+    stopSocialImage: (all = false) => api2.request(`${base}/social/image-job${all ? "?all=true" : ""}`, {
+      method: "DELETE"
+    }),
     /** Maggie changes the post as asked, in 3-255 characters (one AI generation). */
     rewriteSocial: (id, instruction) => post(`${base}/social/${id}/rewrite`, { instruction }),
     /** Maggie plans and writes a series; it waits for one OK. */
@@ -7760,13 +7860,35 @@ function domainApi(api2, domain) {
       brief: brief2,
       ...channels ? { channels } : {}
     }),
+    // In the background: the answer is the job at once; watch `write_jobs` in GET /social.
+    startSocialFromPhotos: (photos, brief2 = "", channels) => post(`${base}/social/from-photos`, {
+      photos,
+      brief: brief2,
+      background: true,
+      ...channels ? { channels } : {}
+    }),
+    startSocialFromPost: (sourcePostId, channels) => post(`${base}/social/from-post`, {
+      source_post_id: sourcePostId,
+      background: true,
+      ...channels ? { channels } : {}
+    }),
+    startSocialPlan: (days, timezone, channels) => post(`${base}/social/plan`, {
+      days,
+      timezone,
+      background: true,
+      ...channels ? { channels } : {}
+    }),
+    startWriteSocialIdea: (id, channels) => post(`${base}/social/ideas/${id}/write`, {
+      background: true,
+      ...channels ? { channels } : {}
+    }),
     /** Disconnect the website's LinkedIn account. */
     disconnectLinkedIn: (connectionId) => api2.request(`${base}/social/linkedin/${connectionId}`, { method: "DELETE" }),
     /** Published articles a LinkedIn post can be made from. */
     socialSources: (search = "") => api2.request(
       `${base}/social/sources?search=${encodeURIComponent(search)}`
     ),
-    /** Maggie writes a LinkedIn draft about one article. */
+    /** Maggie writes a post about one article for each channel; `failed` lists a channel that could not be written while the others were. */
     socialFromPost: (sourcePostId, channels) => post(`${base}/social/from-post`, {
       source_post_id: sourcePostId,
       ...channels ? { channels } : {}
@@ -7825,13 +7947,49 @@ function domainApi(api2, domain) {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ publish_mode: mode })
     }),
+    /** A Google Business post's button (LEARN_MORE, BOOK, ORDER, SHOP, SIGN_UP, CALL); "" = Learn more. */
+    setSocialButton: (id, ctaType) => api2.request(`${base}/social/${id}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ cta_type: ctaType })
+    }),
+    /** Make a Google Business post an Event or Offer (or back to an update with { type: "STANDARD" }). */
+    setSocialGooglePost: (id, googlePost) => api2.request(`${base}/social/${id}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ google_post: googlePost })
+    }),
     resumeSocial: () => post(`${base}/social/resume`),
+    /** Start a video upload: PUT each part_size slice of the file to its url, keep the ETags, then completeVideoUpload. */
+    startVideoUpload: (file) => post(
+      `${base}/social/video/upload`,
+      file
+    ),
+    completeVideoUpload: (videoId, parts, edit) => post(`${base}/social/video/${videoId}/complete`, { parts, edit }),
+    /** A direct link to a video file (not a YouTube / TikTok page). */
+    videoFromLink: (url, edit) => post(`${base}/social/video/link`, { url, edit }),
+    video: (videoId) => api2.request(`${base}/social/video/${videoId}`),
+    /** Another part or framing; prepared again in the background. */
+    editVideo: (videoId, edit) => post(`${base}/social/video/${videoId}/edit`, { edit }),
+    /** A YouTube post from a ready video, waiting in Review; Maggie writes the details unless write is false. */
+    postFromVideo: (videoId, opts = {}) => post(`${base}/social/video/${videoId}/post`, opts),
+    youtubeSettings: () => api2.request(`${base}/social/youtube/settings`),
+    setYouTubeSettings: (s) => put(`${base}/social/youtube/settings`, s),
+    /** A YouTube post's title, tags, visibility, made-for-kids or altered-content answer. */
+    setSocialYouTube: (id, answers) => api2.request(`${base}/social/${id}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ youtube: answers })
+    }),
     pauseAutopilot: () => post(`${base}/autopilot/pause`),
     resumeAutopilot: () => post(`${base}/autopilot/resume`),
     // Reports (docs/18 §6): report:read with the user's own key.
     visibility: () => api2.request(`${base}/visibility`),
     searchConsole: (period2 = "30d") => api2.request(`${base}/search-console?period=${period2}`),
     searchConsoleQueries: (period2 = "30d", filter = "top", limit = 20) => api2.request(`${base}/search-console/queries?period=${period2}&filter=${filter}&limit=${limit}`),
+    /** A Google sign-in link that connects Search Console for this website (open it in a
+     *  browser; back at returnTo with ?gsc=connected or ?gsc=error&message=…). 10 minutes. */
+    connectSearchConsole: (returnTo = "close") => post(`${base}/search-console/connect`, { return_to: returnTo }),
     /** Fresh numbers from Google now; at most once an hour per website. */
     syncSearchConsole: () => post(`${base}/search-console/sync`),
     contentPerformance: (sort = "clicks", band, limit = 20) => api2.request(
@@ -8243,6 +8401,22 @@ var confirmCopy = {
     en: (a) => `Bring back LinkedIn post #${a.id}.`,
     "zh-Hant": (a) => `\u6062\u5FA9 LinkedIn \u8CBC\u6587 #${a.id}\u3002`
   },
+  youtube_connect_link: {
+    en: () => "Make a link to connect your YouTube channel.",
+    "zh-Hant": () => "\u7522\u751F\u9023\u63A5\u4F60 YouTube \u983B\u9053\u7684\u9023\u7D50\u3002"
+  },
+  social_video_add: {
+    en: (a) => `Make a YouTube post from ${a.url}${a.write === false ? "" : " (Maggie writes the title and description: one AI generation)"}; it waits for your OK.`,
+    "zh-Hant": (a) => `\u7528 ${a.url} \u505A\u4E00\u5247 YouTube \u5F71\u7247\u8CBC\u6587${a.write === false ? "" : "\uFF08Maggie \u5BEB\u6A19\u984C\u548C\u8AAA\u660E\uFF1A\u7528\u4E00\u6B21 AI \u751F\u6210\uFF09"}\uFF0C\u7B49\u4F60\u78BA\u8A8D\u5F8C\u624D\u767C\u3002`
+  },
+  social_youtube_set: {
+    en: (a) => `Change YouTube post #${a.id}: ${keys(a).filter((k) => k !== "id").join(", ") || "its details"}.`,
+    "zh-Hant": (a) => `\u4FEE\u6539 YouTube \u8CBC\u6587 #${a.id}\uFF1A${keys(a).filter((k) => k !== "id").join("\u3001") || "\u7D30\u7BC0"}\u3002`
+  },
+  youtube_settings_set: {
+    en: (a) => `Change your YouTube defaults: ${keys(a).join(", ") || "nothing"}.`,
+    "zh-Hant": (a) => `\u4FEE\u6539 YouTube \u9810\u8A2D\uFF1A${keys(a).join("\u3001") || "\u7121"}\u3002`
+  },
   social_image_new: {
     en: (a) => `Make a new picture for LinkedIn post #${a.id}${a.instruction ? `: ${String(a.instruction).slice(0, 300)}` : ""} (1 AI generation, in the background)${a.replace ? ", stopping the one being made for another post" : ""}.`,
     "zh-Hant": (a) => `\u70BA LinkedIn \u8CBC\u6587 #${a.id} \u751F\u6210\u65B0\u5716\u7247${a.instruction ? `\uFF1A${String(a.instruction).slice(0, 300)}` : ""}\uFF08\u7528 1 \u6B21 AI \u751F\u6210\uFF0C\u5728\u80CC\u666F\u9032\u884C\uFF09${a.replace ? "\uFF0C\u4E26\u505C\u6B62\u6B63\u5728\u70BA\u53E6\u4E00\u7BC7\u751F\u6210\u7684\u5716\u7247" : ""}\u3002`
@@ -9776,7 +9950,7 @@ var brief = (m) => ({
 var memoryTools = [
   tool({
     name: "memory_get",
-    description: "The user's Maggie Memory on this website: their saved taste per channel (general, blog, linkedin, facebook) as prefer / always / never items, each with an id. Already in your instructions when it is on; read it to answer what you remember or to find an id to forget.",
+    description: "The user's Maggie Memory on this website: their saved taste per channel (general, blog, linkedin, facebook, instagram, google_business) as prefer / always / never items, each with an id. Already in your instructions when it is on; read it to answer what you remember or to find an id to forget.",
     parameters: none,
     group: "memory",
     need: own,
@@ -10074,9 +10248,21 @@ var reportTools = [
       };
     }
   }),
+  tool({
+    name: "gsc_connect_link",
+    description: "A Google sign-in link for the user to connect Google Search Console for this website (or reconnect). Give them the link to open; never ask for their Google password. They must sign in with a Google account that can see this website in Search Console; if it can't, the page says which account and how to add it.",
+    parameters: none,
+    group: "reports",
+    need: { resource: "autopilot", level: "write" },
+    risk: "W1",
+    run: async (ctx) => {
+      const out = await ws(ctx).connectSearchConsole("close");
+      return { url: out.url, expires_in_seconds: out.expires_in_seconds };
+    }
+  }),
   tool({
     name: "gsc_performance_get",
-    description: "Google Search Console for the period (30d, 90d or 12m): clicks, impressions, CTR and average position, with the change against the period before, the daily trend and the top pages.",
+    description: "Google Search Console for the period (30d, 90d or 12m): clicks, impressions, CTR and average position, with the change against the period before (clicks and impressions as a ratio: -0.25 = 25% fewer, null when there was nothing before; ctr in points as a fraction; position in places, lower is better), the daily trend and the top pages.",
     parameters: { type: "object", properties: { period: { type: "string", enum: periods } } },
     group: "reports",
     need: read4,
@@ -10243,16 +10429,24 @@ var reportTools = [
 var read5 = { resource: "autopilot", level: "read" };
 var write5 = { resource: "autopilot", level: "write" };
 var moves2 = ["up", "down", "top"];
-var CHANNEL_KEYS = ["linkedin", "facebook"];
+var CHANNEL_KEYS = ["linkedin", "facebook", "instagram", "google_business"];
+var ALL_CHANNEL_KEYS = [...CHANNEL_KEYS, "youtube"];
 var channelsParam = {
   type: "array",
   items: { type: "string", enum: CHANNEL_KEYS },
-  description: "Which channels to write for: linkedin, facebook. Leave out to write for every connected channel (one post each, one credit each); give one only when the user names it."
+  description: "Which channels to write for: linkedin, facebook, instagram, google_business. Leave out to write for every connected channel (one post each, one credit each); give one only when the user names it. YouTube takes a video: use social_video_add."
 };
 var channelsOf = (value) => {
   const list2 = Array.isArray(value) ? value.map((v) => String(v).toLowerCase()).filter((v) => CHANNEL_KEYS.includes(v)) : [];
   return list2.length ? list2 : void 0;
 };
+var writing = (job) => ({
+  job_id: job.id,
+  status: "writing",
+  posts_expected: job.expected,
+  channels: job.channels,
+  note: "Maggie is writing in the background (a minute or two). Tell the user they'll be told when it's ready; social_write_status says when it's done."
+});
 var item = (i) => ({
   id: i.id,
   channel: i.provider || "linkedin",
@@ -10263,7 +10457,11 @@ var item = (i) => ({
   campaign: i.campaign ?? null,
   failure: i.failure_message ?? null,
   link: i.provider_permalink ?? null,
-  text: clip(i.social_copy, 300)
+  text: clip(i.social_copy, 300),
+  ...i.provider === "youtube" ? {
+    youtube: i.youtube ?? null,
+    video: i.video ? { status: i.video.status, seconds: i.video.duration, shape: i.video.shape, error: i.video.error } : null
+  } : {}
 });
 var socialTools = [
   tool({
@@ -10371,7 +10569,7 @@ var socialTools = [
   }),
   tool({
     name: "social_image_new",
-    description: "Make a new picture for a LinkedIn post that hasn't gone out (uses 1 AI generation). It is made in the background, on the user's own ChatGPT when their Maggie Bridge has images on, else by CMO.so; it takes up to a couple of minutes and appears on the post by itself (check with social_image_status). One picture is made at a time per website: if another is being made this fails with image_busy; only pass replace: true when the user agrees to stop that one. A post written from an article gets its own picture (from its text and the article's title) and then goes out as that picture.",
+    description: "Make a new picture for a social post that hasn't gone out, or change its current one (mode: edit, as `instruction` says). Uses 1 AI generation. It is made in the background, on the user's own ChatGPT when their Maggie Bridge has images on, else by CMO.so; it takes up to a couple of minutes and appears on the post by itself (check with social_image_status). One picture is made at a time per website: while another is being made this one waits in line (status queued). It fails with image_busy only when this post already has one being made or in line; pass replace: true only when the user agrees to stop the one being made and make this one now. A post written from an article gets its own picture (from its text and the article's title) and then goes out as that picture. Every new picture carries a short title and line set on it; count: 4 makes a set of 4 pictures that tell one story (still 1 AI generation, drawn as one storyboard and cut); LinkedIn and Facebook post a set together as a collage. text_effect picks the style of those words (an id from social_text_effects); leave it out to let Maggie pick. style picks the picture style (an id from social_look: photo_headline, editorial, duotone, illustrated, bold_type, infographic); leave it out and Maggie takes turns with the brand's 3. bold_type and infographic make no AI picture (big words or a list in the brand's look) and cost nothing.",
     parameters: {
       type: "object",
       properties: {
@@ -10380,6 +10578,23 @@ var socialTools = [
         instruction: {
           type: "string",
           description: "What the user wants in the picture, in their words (up to 300 characters), e.g. 'gold border, our logo, Future 100 \xB7 2025'. Leave out when they gave no direction."
+        },
+        mode: {
+          type: "string",
+          enum: ["new", "edit"],
+          description: "edit: change the post's current picture as the instruction says (it must have one)"
+        },
+        count: {
+          type: "integer",
+          description: "1 (default) or 4: a set of 4 pictures telling one story, a line of words on each"
+        },
+        text_effect: {
+          type: "string",
+          description: "For a set: the words' style id from social_text_effects (omit = Maggie picks)"
+        },
+        style: {
+          type: "string",
+          description: "Picture style id from social_look (omit = Maggie picks from the brand's 3)"
         }
       },
       required: ["id"]
@@ -10388,36 +10603,253 @@ var socialTools = [
     need: write5,
     risk: "W2",
     gates: ["VER", "CR"],
-    run: async (ctx, { id, replace, instruction }) => {
+    run: async (ctx, { id, replace, instruction, mode, count, text_effect, style }) => {
       const out = await ws(ctx).regenerateSocialImage(Number(id), {
         replace: replace === true,
+        ...typeof style === "string" && style.trim() && mode !== "edit" ? { style: style.trim() } : {},
+        ...mode === "edit" ? { mode: "edit" } : {},
+        ...Number(count) === 4 && mode !== "edit" ? { count: 4 } : {},
+        ...typeof text_effect === "string" && text_effect.trim() ? { textEffect: text_effect.trim() } : {},
         ...typeof instruction === "string" && instruction.trim() ? { instruction: instruction.trim().slice(0, 300) } : {}
       });
       return {
         id: out.id,
         image_job: out.image_job,
-        note: "Making it in the background; it shows on the post when ready."
+        note: out.image_job?.status === "queued" ? "In line after the picture being made now; it shows on the post when ready." : "Making it in the background; it shows on the post when ready."
+      };
+    }
+  }),
+  tool({
+    name: "social_images_fill",
+    description: "A new picture for every social post here that hasn't gone out and has none (or only these ids), made one after another in the background: 1 AI generation each. A LinkedIn and a Facebook post of the same idea share one picture. Says how many are in line, how many already were, and why it stopped early (the line is full, or the day's AI generations ran out). Preview the count first.",
+    parameters: {
+      type: "object",
+      properties: {
+        ids: { type: "array", items: { type: "integer" }, description: "Only these posts (from social_list)" },
+        instruction: { type: "string", description: "What the user wants in every picture, up to 300 characters" }
+      }
+    },
+    group: "social",
+    need: write5,
+    risk: "W2",
+    gates: ["VER", "CR"],
+    run: async (ctx, { ids: ids2, instruction }) => {
+      const out = await ws(ctx).fillSocialImages({
+        ...Array.isArray(ids2) && ids2.length ? { item_ids: ids2.map(Number) } : {},
+        ...typeof instruction === "string" && instruction.trim() ? { instruction: instruction.trim().slice(0, 300) } : {}
+      });
+      return { queued: out.queued, already: out.skipped, stopped_because: out.message, line: out.image_jobs.length };
+    }
+  }),
+  tool({
+    name: "social_text_effects",
+    description: "The styles for the words on a set of pictures (social_image_new with count 4): id, name, family and a sample picture URL. Use when the user wants to choose how the words look ('bold sticker', 'neon', 'gold').",
+    parameters: none,
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx) => {
+      const out = await ws(ctx).socialTextEffects();
+      return { effects: out.effects.map(({ id, name, family }) => ({ id, name, family })), auto: out.auto };
+    }
+  }),
+  tool({
+    name: "social_look",
+    description: "The brand's picture look on this website (made the first time it's asked for): the 3 picture styles Maggie takes turns with, the 5 text styles she picks from per picture, two fonts, the colours (ink, paper, primary, accent, muted), a short description of how its photos look, and things never to show; plus every style, font and text style that can be chosen. Read it before changing the look or when the user asks how their pictures look.",
+    parameters: none,
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx) => {
+      const l = await ws(ctx).socialLook();
+      return {
+        styles: l.styles.map((s) => ({ id: s.id, name: s.name, about: s.about })),
+        text_effects: l.text_effects.map((e) => ({ id: e.id, name: e.name, family: e.family })),
+        fonts: l.fonts,
+        colours: l.colours,
+        description: l.brand_suffix,
+        never: l.never,
+        why: l.suggested.reason ?? null,
+        can_choose: {
+          styles: l.catalogue.styles.map((s) => ({ id: s.id, name: s.name, led: s.led, needs_photo: s.needs_photo })),
+          fonts: l.catalogue.fonts,
+          text_effect_families: [...new Set(l.catalogue.text_effects.map((e) => e.family))]
+        }
       };
     }
   }),
+  tool({
+    name: "social_look_update",
+    description: "Change the brand's picture look: the 3 styles Maggie takes turns with (style_ids, 1-3), the text styles (text_effect_ids, 1-5, ids from social_text_effects), fonts, colours (hex), the description of how photos look, things never to show, or reset: true (back to Maggie's suggestion). New pictures use it; pictures already made keep theirs (social_picture_edit changes one). Preview the change first.",
+    parameters: {
+      type: "object",
+      properties: {
+        style_ids: { type: "array", items: { type: "string" }, description: "1-3 picture style ids" },
+        text_effect_ids: { type: "array", items: { type: "string" }, description: "1-5 text style ids" },
+        font_display: { type: "string", description: "Font for big words (from social_look can_choose.fonts)" },
+        font_body: { type: "string", description: "Font for lines and lists" },
+        colours: {
+          type: "object",
+          description: "Any of these as #RRGGBB",
+          properties: {
+            ink: { type: "string", description: "Text on paper" },
+            paper: { type: "string", description: "The light ground" },
+            primary: { type: "string", description: "The brand colour" },
+            accent: { type: "string", description: "A second colour" },
+            muted: { type: "string", description: "Small text" }
+          }
+        },
+        description: { type: "string", description: "How the brand's photos look, up to 600 characters" },
+        never: { type: "array", items: { type: "string" }, description: "Things never to show (the whole list)" },
+        reset: { type: "boolean", description: "Back to Maggie's suggested look" }
+      }
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, a) => {
+      const fonts = {
+        ...a.font_display ? { display: a.font_display } : {},
+        ...a.font_body ? { body: a.font_body } : {}
+      };
+      const l = await ws(ctx).updateSocialLook({
+        ...a.style_ids ? { style_ids: a.style_ids } : {},
+        ...a.text_effect_ids ? { text_effect_ids: a.text_effect_ids } : {},
+        ...Object.keys(fonts).length ? { fonts } : {},
+        ...a.colours ? { colours: a.colours } : {},
+        ...typeof a.description === "string" ? { brand_suffix: a.description } : {},
+        ...a.never ? { never: a.never } : {},
+        ...a.reset ? { reset: true } : {}
+      });
+      return {
+        styles: l.styles.map((s) => s.id),
+        text_effects: l.text_effects.map((e) => e.id),
+        fonts: l.fonts,
+        colours: l.colours
+      };
+    }
+  }),
+  tool({
+    name: "social_picture_edit",
+    description: "Change a picture Maggie made for a post that hasn't gone out, without making a new one (free, a few seconds): the words on each picture (title up to 60 characters, line up to 90), its picture style, its text style, or for a set the order (indexes, 0 = first) or pictures to drop. Only posts whose picture says editable in social_list; a photo style needs the picture's photos (has_photos). Changing the words of one picture: send every picture's words in order. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "The post (from social_list)" },
+        words: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { headline: { type: "string" }, sub: { type: "string" } },
+            required: ["headline"]
+          },
+          description: "The words on each picture, in order (in the new order when order is given)"
+        },
+        style: { type: "string", description: "A picture style id from social_look" },
+        text_effect: { type: "string", description: "A text style id from social_text_effects" },
+        order: { type: "array", items: { type: "integer" }, description: "The pictures in their new order" },
+        remove: { type: "array", items: { type: "integer" }, description: "Pictures to drop from a set" }
+      },
+      required: ["id"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, { id, words, style, text_effect, order, remove: remove2 }) => {
+      const out = await ws(ctx).editSocialPicture(Number(id), {
+        ...Array.isArray(words) ? { words: words.map((w) => ({ headline: String(w.headline ?? ""), sub: String(w.sub ?? "") })) } : {},
+        ...style ? { style } : {},
+        ...text_effect ? { text_effect } : {},
+        ...Array.isArray(order) ? { order: order.map(Number) } : {},
+        ...Array.isArray(remove2) ? { remove: remove2.map(Number) } : {}
+      });
+      return { id: out.id, pictures: out.image_urls?.length ? out.image_urls : [out.image_url], picture: out.picture };
+    }
+  }),
+  tool({
+    name: "social_photo_words",
+    description: "Put a title and a line on the user's own photo(s) on a post, in the brand's look: Maggie writes the words from the post (no AI picture, free). Only for a post whose picture is the user's own photo (own_photo in social_list). style: real_photo (default, the photo framed with the words below), product_hero (the words on a card), or another photo style. Then social_picture_edit changes the words. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "The post (from social_list)" },
+        style: {
+          type: "string",
+          description: "real_photo (default), product_hero, photo_headline, editorial, duotone"
+        }
+      },
+      required: ["id"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, { id, style }) => {
+      const out = await ws(ctx).wordsOnPhoto(Number(id), style || "real_photo");
+      return { id: out.id, picture: out.picture, pictures: out.image_urls?.length ? out.image_urls : [out.image_url] };
+    }
+  }),
+  tool({
+    name: "social_post_insights",
+    description: "How a posted Instagram post is doing: views, reach, likes, comments, saves and shares, read from Instagram (kept 15 minutes; refresh: true reads again). Saves and shares per reach are the best signs of a good post. available: false says why (not posted yet, deleted on Instagram, the account needs reconnecting).",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "A posted Instagram post (from social_list posted)" },
+        refresh: { type: "boolean", description: "Read the numbers again now" }
+      },
+      required: ["id"]
+    },
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx, { id, refresh }) => ws(ctx).socialInsights(Number(id), refresh === true)
+  }),
+  tool({
+    name: "social_write_status",
+    description: "Posts Maggie is writing in the background for this user on this website (from social_from_article, social_plan_days, social_idea_write or the app), and the ones finished in the last 10 minutes: running, done (the new post ids) or failed (why), and any channel that couldn't be written. Look once when the user asks, not in a loop.",
+    parameters: none,
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx) => ({
+      jobs: ((await ws(ctx).social()).write_jobs ?? []).map((j) => ({
+        id: j.id,
+        kind: j.kind,
+        status: j.status,
+        channels: j.channels,
+        expected: j.expected,
+        written: j.item_ids,
+        queued: j.queued,
+        ...j.failed?.length ? { failed: j.failed } : {},
+        ...j.error ? { error: j.error } : {},
+        started_at: j.started_at
+      }))
+    })
+  }),
   tool({
     name: "social_image_status",
-    description: "Whether a new LinkedIn picture is being made on this website (which post, since when), or how the last one ended (done, failed with why, stopped) and who drew it (chatgpt or gemini).",
+    description: "The picture being made on this website and those waiting in line (which post, new or edit), or how the last one ended (done, failed with why, stopped) and who drew it (chatgpt or gemini).",
     parameters: none,
     group: "social",
     need: read5,
     risk: "R0",
-    run: async (ctx) => ({ image_job: (await ws(ctx).social()).image_job ?? null })
+    run: async (ctx) => {
+      const s = await ws(ctx).social();
+      return { image_job: s.image_job ?? null, line: s.image_jobs ?? [] };
+    }
   }),
   tool({
     name: "social_image_stop",
-    description: "Stop the LinkedIn picture being made on this website; the post keeps the picture it had.",
-    parameters: none,
+    description: "Stop the picture being made on this website (the post keeps the picture it had; the next in line starts). all: true also empties the line.",
+    parameters: { type: "object", properties: { all: { type: "boolean" } } },
     group: "social",
     need: write5,
     risk: "W1",
     gates: ["VER"],
-    run: async (ctx) => ws(ctx).stopSocialImage()
+    run: async (ctx, { all }) => ws(ctx).stopSocialImage(all === true)
   }),
   tool({
     name: "social_move",
@@ -10438,7 +10870,7 @@ var socialTools = [
     description: "Pause or resume the user's social posting: one channel (linkedin or facebook), or every channel when no channel is given.",
     parameters: {
       type: "object",
-      properties: { paused: { type: "boolean" }, channel: { type: "string", enum: CHANNEL_KEYS } },
+      properties: { paused: { type: "boolean" }, channel: { type: "string", enum: ALL_CHANNEL_KEYS } },
       required: ["paused"]
     },
     group: "social",
@@ -10461,7 +10893,7 @@ var socialTools = [
   }),
   tool({
     name: "social_from_article",
-    description: "Maggie writes a post about one published article (id from social_sources_list) for each channel. It waits for the user's OK as a draft, unless their approval mode is auto (then it goes to the front of the queue).",
+    description: "Maggie writes a post about one published article (id from social_sources_list) for each channel. It waits for the user's OK as a draft, unless their approval mode is auto (then it goes to the front of the queue). Written in the background (a minute or two): this returns at once with a job. Tell the user Maggie is writing and they will be told when it's ready; before saying what was written, check social_write_status (then social_list for the posts).",
     parameters: {
       type: "object",
       properties: {
@@ -10475,14 +10907,11 @@ var socialTools = [
     need: write5,
     risk: "W2",
     gates: ["VER", "LI", "LLM"],
-    run: async (ctx, { source_id, channels }) => {
-      const out = await ws(ctx).socialFromPost(String(source_id), channelsOf(channels));
-      return { id: out.id, status: out.status, queued: Boolean(out.queued), text: clip(out.social_copy, 300) };
-    }
+    run: async (ctx, { source_id, channels }) => writing((await ws(ctx).startSocialFromPost(String(source_id), channelsOf(channels))).job)
   }),
   tool({
     name: "social_plan_days",
-    description: "Maggie writes posts for the next 1\u20137 days from the best recent articles, on each channel. They wait for the user's OK as drafts, unless the user's approval mode is auto (then they are queued in order).",
+    description: "Maggie writes posts for the next 1\u20137 days from the best recent articles, on each channel. They wait for the user's OK as drafts, unless the user's approval mode is auto (then they are queued in order). Written in the background (a minute or two): this returns at once with a job. Tell the user Maggie is writing and they will be told when it's ready; before saying what was written, check social_write_status (then social_list for the posts).",
     parameters: {
       type: "object",
       properties: {
@@ -10496,10 +10925,7 @@ var socialTools = [
     need: write5,
     risk: "W2",
     gates: ["VER", "LI", "LLM"],
-    run: async (ctx, { days, timezone, channels }) => {
-      const out = await ws(ctx).socialPlan(int(days, 1, 7, 3), timezone || "UTC", channelsOf(channels));
-      return { written: out.items.length, queued: Boolean(out.queued), items: out.items.map(item) };
-    }
+    run: async (ctx, { days, timezone, channels }) => writing((await ws(ctx).startSocialPlan(int(days, 1, 7, 3), timezone || "UTC", channelsOf(channels))).job)
   }),
   tool({
     name: "social_ideas_list",
@@ -10572,7 +10998,7 @@ var socialTools = [
   }),
   tool({
     name: "social_idea_write",
-    description: "Maggie writes one idea's post for each channel (1 credit per post). The user's own idea's posts wait for their OK (queued straight away only in approval mode auto); a campaign's wait for the campaign to start.",
+    description: "Maggie writes one idea's post for each channel (1 credit per post). The user's own idea's posts wait for their OK (queued straight away only in approval mode auto); a campaign's wait for the campaign to start. Written in the background (a minute or two): this returns at once with a job. Tell the user Maggie is writing and they will be told when it's ready; before saying what was written, check social_write_status (then social_list for the posts).",
     parameters: {
       type: "object",
       properties: {
@@ -10586,7 +11012,7 @@ var socialTools = [
     need: write5,
     risk: "W2",
     gates: ["VER", "LI", "CR", "LLM"],
-    run: async (ctx, { id, channels }) => ws(ctx).writeSocialIdea(Number(id), void 0, channelsOf(channels))
+    run: async (ctx, { id, channels }) => writing((await ws(ctx).startWriteSocialIdea(Number(id), channelsOf(channels))).job)
   }),
   tool({
     name: "social_idea_brief",
@@ -10883,9 +11309,9 @@ var socialTools = [
     run: async (ctx, { keys: keys2, ...options }) => {
       const api2 = ws(ctx);
       const current = (await api2.socialSetup()).writing;
-      const writing = { ...current };
-      for (const [k, v] of Object.entries(options)) if (v !== void 0) writing[k] = v;
-      return api2.socialSetupTemplates((keys2 ?? []).slice(0, 10), writing);
+      const writing2 = { ...current };
+      for (const [k, v] of Object.entries(options)) if (v !== void 0) writing2[k] = v;
+      return api2.socialSetupTemplates((keys2 ?? []).slice(0, 10), writing2);
     }
   }),
   tool({
@@ -10966,6 +11392,220 @@ var socialTools = [
       const out = await ws(ctx).connectFacebook("close");
       return { url: out.url, expires_in_seconds: out.expires_in_seconds };
     }
+  }),
+  tool({
+    name: "google_business_connect_link",
+    description: "A link for the user to connect their Google Business Profile (or reconnect): they sign in with the Google account that manages the profile; every profile it can post to is saved and the one whose website is this site is picked (else they pick it in the app). Only verified profiles can post. Give them the link to open; never ask for a password. Google posts are short local updates with one photo and a button; Google checks each one before it shows.",
+    parameters: none,
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx) => {
+      const out = await ws(ctx).connectGoogleBusiness("close");
+      return { url: out.url, expires_in_seconds: out.expires_in_seconds };
+    }
+  }),
+  tool({
+    name: "social_google_button",
+    description: "Set the button on a Google Business post that hasn't gone out: LEARN_MORE (default, opens the post's link), BOOK (a booking link), ORDER, SHOP, SIGN_UP, or CALL (calls the profile's phone number; needs no link). Pick the one that matches what the post asks people to do. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "A Google Business post (from social_list)" },
+        button: { type: "string", enum: ["LEARN_MORE", "BOOK", "ORDER", "SHOP", "SIGN_UP", "CALL"] }
+      },
+      required: ["id", "button"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, { id, button }) => {
+      const out = await ws(ctx).setSocialButton(Number(id), button);
+      return { id: out.id, button: out.cta_type ?? "LEARN_MORE", link: out.cta_url ?? null };
+    }
+  }),
+  tool({
+    name: "youtube_connect_link",
+    description: "A link for the user to connect their YouTube channel (or reconnect): they sign in with the Google account that owns the channel and allow Maggie to upload videos and see the channel. Give them the link to open; never ask for a password. YouTube posts are short videos (5-30 seconds now) that the user approves one by one.",
+    parameters: none,
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx) => {
+      const out = await ws(ctx).connectYouTube("close");
+      return { url: out.url, expires_in_seconds: out.expires_in_seconds };
+    }
+  }),
+  tool({
+    name: "social_video_add",
+    description: "Make a YouTube post from a video: a DIRECT link to a video file (an .mp4 on their website, a public Dropbox link), never a YouTube / TikTok / Instagram page (we never download those; tell the user to upload the video in the app instead). The video must be 5-30 seconds: give start/end (seconds) to use a part of a longer one. vertical: make a wide video vertical (a Short) cropped at left, middle or right. Maggie writes the title, description and tags from the video and the note (one AI generation) unless write is false. The post waits in Review: YouTube posts are always approved by the user, who must also answer whether it's made for kids. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Direct https link to the video file" },
+        note: { type: "string", description: "What the video is about, in the user's words" },
+        write: { type: "boolean", description: "Let Maggie write the details (default true)" },
+        start: { type: "number", description: "Start of the part to use, seconds" },
+        end: { type: "number", description: "End of the part to use, seconds" },
+        vertical: { type: "string", enum: ["left", "middle", "right"] }
+      },
+      required: ["url"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W2",
+    gates: ["VER", "LLM"],
+    run: async (ctx, a) => {
+      const d = ws(ctx);
+      const edit = {
+        ...a.start != null ? { start: Number(a.start) } : {},
+        ...a.end != null ? { end: Number(a.end) } : {},
+        ...a.vertical ? { aspect: "9:16", crop_x: a.vertical === "left" ? 0 : a.vertical === "right" ? 1 : 0.5 } : {}
+      };
+      let v = await d.videoFromLink(String(a.url), Object.keys(edit).length ? edit : void 0);
+      const until = Date.now() + 15e4;
+      while ((v.status === "checking" || v.status === "uploading") && Date.now() < until) {
+        await new Promise((r) => setTimeout(r, 3e3));
+        v = await d.video(v.id);
+      }
+      if (v.status !== "ready")
+        return { ok: false, video: { status: v.status, error: v.error, seconds: v.source_duration } };
+      const post = await d.postFromVideo(v.id, { note: a.note ?? "", write: a.write !== false });
+      return {
+        ok: true,
+        post: item(post),
+        next: "Show the title and description; ask whether it's made for kids and which visibility, then social_youtube_set; the user approves it."
+      };
+    }
+  }),
+  tool({
+    name: "social_youtube_set",
+    description: "Change a YouTube post that hasn't gone out: title (at most 100 characters, aim 40-60), tags, visibility (public, unlisted, private), made_for_kids (YouTube asks for every video: ask the user, never guess) or synthetic (realistic AI-made or altered content). The description is the post's text (social_update_copy). Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "A YouTube post (from social_list)" },
+        title: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        privacy: { type: "string", enum: ["public", "unlisted", "private"] },
+        made_for_kids: { type: "boolean" },
+        synthetic: { type: "boolean" }
+      },
+      required: ["id"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, { id, ...rest }) => {
+      const answers = Object.fromEntries(
+        Object.entries(rest).filter(([, v]) => v !== void 0)
+      );
+      const out = await ws(ctx).setSocialYouTube(Number(id), answers);
+      return item(out);
+    }
+  }),
+  tool({
+    name: "youtube_settings",
+    description: "The user's YouTube defaults for new posts on this website: visibility, made_for_kids (null = asked each time), category and altered content.",
+    parameters: none,
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx) => ws(ctx).youtubeSettings()
+  }),
+  tool({
+    name: "youtube_settings_set",
+    description: "Change the YouTube defaults for new posts: privacy (public, unlisted, private), made_for_kids (yes / no for every video, or ask per video) and synthetic. Only what the user says. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        privacy: { type: "string", enum: ["public", "unlisted", "private"] },
+        made_for_kids: {
+          type: "string",
+          enum: ["yes", "no", "ask"],
+          description: "yes / no for every new video, or ask (answer per video)"
+        },
+        synthetic: { type: "boolean" }
+      }
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, a) => ws(ctx).setYouTubeSettings({
+      ...a.privacy ? { privacy: a.privacy } : {},
+      ...a.made_for_kids ? { made_for_kids: a.made_for_kids === "ask" ? null : a.made_for_kids === "yes" } : {},
+      ...a.synthetic != null ? { synthetic: a.synthetic } : {}
+    })
+  }),
+  tool({
+    name: "google_business_performance",
+    description: "How the website's Google Business Profile is doing: views on Google Search and Maps, website clicks, calls and direction requests for the last 28 days next to the 28 before (Google's numbers lag 2-3 days). Use it when the user asks how their Google listing or local presence is doing, or to show what Google posts are worth. Compare with the previous 28 days; don't invent reasons for changes.",
+    parameters: {
+      type: "object",
+      properties: { refresh: { type: "boolean", description: "Read Google again now (else up to 6 hours old)" } }
+    },
+    group: "social",
+    need: read5,
+    risk: "R0",
+    run: async (ctx, { refresh }) => ws(ctx).googleBusinessPerformance(refresh === true)
+  }),
+  tool({
+    name: "social_google_post_type",
+    description: "Make a Google Business post that hasn't gone out an EVENT (an open day, a workshop: title up to 58 characters, start and end dates YYYY-MM-DD, optional times HH:MM) or an OFFER (title, dates, optional coupon code, terms and redeem link; Google adds a View offer button), or back to STANDARD (an update). Offers are refused for regulated categories (finance, health, alcohol, gambling) and hotels: use an update or an event. Only real dates and offers the user gave. Preview first.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "integer", description: "A Google Business post (from social_list)" },
+        type: { type: "string", enum: ["STANDARD", "EVENT", "OFFER"] },
+        title: { type: "string", description: "Event or offer title, up to 58 characters" },
+        start: { type: "string", description: "YYYY-MM-DD" },
+        end: { type: "string", description: "YYYY-MM-DD (defaults to start)" },
+        start_time: { type: "string", description: "HH:MM (optional)" },
+        end_time: { type: "string", description: "HH:MM (optional)" },
+        coupon: { type: "string", description: "Offer code (optional)" },
+        terms: { type: "string", description: "Offer terms (optional)" },
+        redeem_url: { type: "string", description: "Where to redeem the offer online (optional)" }
+      },
+      required: ["id", "type"]
+    },
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx, a) => {
+      const type = String(a.type).toUpperCase();
+      const body = type === "STANDARD" ? { type: "STANDARD" } : {
+        type,
+        title: String(a.title ?? ""),
+        start: String(a.start ?? ""),
+        ...a.end ? { end: a.end } : {},
+        ...a.start_time ? { start_time: a.start_time } : {},
+        ...a.end_time ? { end_time: a.end_time } : {},
+        ...a.coupon ? { coupon: a.coupon } : {},
+        ...a.terms ? { terms: a.terms } : {},
+        ...a.redeem_url ? { redeem_url: a.redeem_url } : {}
+      };
+      const out = await ws(ctx).setSocialGooglePost(Number(a.id), body);
+      return { id: out.id, google_post: out.google_post ?? null };
+    }
+  }),
+  tool({
+    name: "instagram_connect_link",
+    description: "A link for the user to connect Instagram (or reconnect). Instagram connects through the Facebook sign-in: only an Instagram professional account (Business or Creator) linked to one of their Facebook Pages can be posted to, so tell them that first. Give them the link to open; never ask for a password. Every Instagram post goes out with its picture (no links in it).",
+    parameters: none,
+    group: "social",
+    need: write5,
+    risk: "W1",
+    gates: ["VER"],
+    run: async (ctx) => {
+      const out = await ws(ctx).connectInstagram("close");
+      return { url: out.url, expires_in_seconds: out.expires_in_seconds };
+    }
   })
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cmo-so/mcp",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"description": "CMO.so's MCP server for Claude Desktop, Cursor, VS Code and other MCP clients: manage your websites, blog posts, LinkedIn queue and results with Maggie.",
 	"type": "module",
 	"license": "MIT",