thursday-agent 0.8.0 → 0.10.0

package/seed-skills/insta/instagram/scripts/search.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * What Instagram's own search shows for a topic — posts and reels, with how each
+ * did — and the accounts behind them, read from the data the search page fetches.
+ * One word or a #tag finds more than a phrase.
+ *
+ *   node search.mjs "<topic>" [--type reel|carousel|image] [--max 24] [--out found.json] [--sheet covers.png]
+ */
+import { writeFileSync } from "node:fs";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+import { media, postLine, short } from "./media.mjs";
+import { makeSheet } from "./sheet.mjs";
+
+const opts = parseArgs();
+const topic = opts._[0];
+if (!topic)
+  fail(
+    'usage: node search.mjs "<topic>" [--type reel|carousel|image] [--max 24] [--out found.json] [--sheet covers.png]',
+  );
+const max = Number(opts.max ?? 24);
+const type = opts.type ?? null;
+if (type && !["reel", "carousel", "image"].includes(type))
+  fail("--type is reel, carousel or image");
+
+const started = Date.now();
+const got = orFail(
+  await inPage(
+    async (page, { topic, max, type }, { media }) => {
+      const found = [];
+      let more = true;
+      let pages = 0;
+      const listen = async (res) => {
+        if (!/\/graphql/.test(res.url())) return;
+        let text;
+        try {
+          text = await res.text();
+        } catch {
+          return;
+        }
+        if (!text.includes("xdt_fbsearch__top_serp_graphql")) return;
+        try {
+          const c = JSON.parse(text.split("\n")[0]).data
+            ?.xdt_fbsearch__top_serp_graphql;
+          pages++;
+          more = Boolean(c?.page_info?.has_next_page);
+          const walk = (o) => {
+            if (!o || typeof o !== "object") return;
+            if (typeof o.code === "string" && "media_type" in o) {
+              found.push(media(o));
+              return;
+            }
+            for (const v of Object.values(o)) walk(v);
+          };
+          walk(c?.edges);
+        } catch {}
+      };
+      const kept = () => found.filter((p) => !type || p.type === type).length;
+      page.on("response", listen);
+      try {
+        await page.goto(
+          `https://www.instagram.com/explore/search/keyword/?q=${encodeURIComponent(topic)}`,
+          { waitUntil: "domcontentloaded" },
+        );
+        for (let i = 0; i < 60 && !pages; i++) await page.waitForTimeout(250);
+        for (let tries = 0; kept() < max && more && tries < 8; tries++) {
+          const had = pages;
+          await page.evaluate(() =>
+            window.scrollTo(0, document.body.scrollHeight),
+          );
+          for (let i = 0; i < 32 && pages === had; i++)
+            await page.waitForTimeout(250);
+          if (pages === had) break;
+        }
+      } finally {
+        page.off("response", listen);
+      }
+      const path = page.url().replace(/^https?:\/\/[^/]+/, "");
+      if (/\/accounts\/login|\/challenge\//.test(path))
+        return {
+          error: `Not signed in (${path}). Borrow the kept sign-in first.`,
+        };
+      if (!pages)
+        return {
+          error:
+            "The search page fetched nothing this script knows (xdt_fbsearch__top_serp_graphql): the page changed, or something covers it. Open it and look.",
+        };
+      const seen = new Set();
+      return {
+        posts: found
+          .filter((p) => !seen.has(p.url) && seen.add(p.url))
+          .filter((p) => !type || p.type === type)
+          .slice(0, max),
+      };
+    },
+    { topic, max, type },
+    { media },
+  ),
+);
+
+const { posts } = got;
+if (opts.out)
+  writeFileSync(opts.out, JSON.stringify({ topic, posts }, null, 1));
+posts.forEach((p, i) => {
+  console.log(postLine(p, i));
+});
+// The accounts behind the results, by the likes they drew here
+const accounts = Object.values(
+  posts.reduce((all, p) => {
+    const a = (all[p.owner] ??= { owner: p.owner, posts: 0, likes: 0 });
+    a.posts++;
+    a.likes += p.likes ?? 0;
+    return all;
+  }, {}),
+).sort((a, b) => b.likes - a.likes);
+console.log(
+  `accounts: ${accounts
+    .slice(0, 10)
+    .map((a) => `@${a.owner} (${a.posts}, likes ${short(a.likes)})`)
+    .join(", ")}`,
+);
+if (opts.sheet) {
+  const made = await makeSheet(
+    posts.map((p, i) => ({
+      src: p.cover,
+      label: `#${i + 1} ${p.type}${p.type === "carousel" ? `×${p.slides}` : ""} likes ${short(p.likes)} @${p.owner}`,
+    })),
+    opts.sheet,
+  );
+  console.log(`covers: ${made.out}`);
+}
+console.log(
+  `${posts.length} results for "${topic}"${type ? ` (${type})` : ""} in ${((Date.now() - started) / 1000).toFixed(1)}s${opts.out ? ` → ${opts.out}` : ""}`,
+);

package/seed-skills/insta/instagram/scripts/selectors.mjs

@@ -0,0 +1,56 @@
+/**
+ * Everything these scripts know about Instagram's page, in one place. Class names
+ * are generated and change with every release, so nothing here is a class: roles,
+ * tags, and the names of props Instagram's own components pass (read off the React
+ * tree, which outlives a restyle). When a script stops with "selectors changed",
+ * open the page, take one snapshot, fix the line here, and note the date.
+ */
+export const SEL = {
+  // Inbox (last checked 2026-09)
+  /** Primary and General share one url and differ by tab (by position: labels are localized). */
+  folders: {
+    primary: { url: "/direct/inbox/", tab: 0 },
+    general: { url: "/direct/inbox/", tab: 1 },
+    requests: { url: "/direct/requests/" },
+  },
+  folderTab: "main [role=tab]",
+  /** The thread list. */
+  inboxList: "main [role=navigation]",
+  /** One thread in it: a pressable row carrying a relative time. */
+  inboxRow: "[role=button]:has(abbr)",
+  /** An unread row draws its title and preview semibold; a read one is normal. */
+  unreadWeight: 600,
+  /** Props on the row's components: the id in /direct/t/<id>/, and its last activity. */
+  threadIdProp: "threadKeyForSelection",
+  lastActivityProp: "last_activity_timestamp_ms",
+
+  // Thread (last checked 2026-09)
+  /** One row of the message list; a message row holds an article, a date line does not. */
+  messageRow: "[role=group]",
+  messageBody: "[role=article]",
+  /** The row's message record: { id, timestamp_ms, sender_fbid }. */
+  messageRefProp: "currentMessageRef",
+  /** True on a message the signed-in account sent. */
+  outgoingProp: "outgoing",
+  /** A picture smaller than this on screen is an avatar or an icon, not an attachment. */
+  minImagePx: 80,
+
+  // Composer (last checked 2026-09)
+  /** Sidebar entries that open something rather than a page; Create is the second (after Notifications). */
+  sidebarAction: 'a[href="#"]',
+  createIndex: 1,
+  /** Below this width the sidebar becomes a bottom bar with Create elsewhere. */
+  wideWidth: 1280,
+  /** The step that takes files; the caption step is the one with a textbox. */
+  composer: "[role=dialog]",
+  fileInput: "input[type=file]",
+  caption: "[role=textbox]",
+  /** The picture on the crop step, drawn as an image or a background. */
+  preview: 'img, [style*="background-image"]',
+  aiLabel: "input[role=switch]",
+  /** Crop options start with their ratio; the first is Original. */
+  cropOptions: ["original", "1:1", "4:5", "16:9"],
+};
+
+/** Instagram's own web client id; its JSON endpoints answer only with it. */
+export const APP_ID = "936619743392459";

package/seed-skills/insta/instagram/scripts/sheet.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Many pictures as one image, each with a label under it, so one look sees a
+ * whole feed: covers side by side, or every slide of one post.
+ *
+ *   node sheet.mjs --out sheet.png <posts.json>              covers of every post
+ *   node sheet.mjs --out sheet.png <posts.json> --post 3     every slide of post 3
+ *   node sheet.mjs --out sheet.png <image url | file>...     any pictures
+ */
+import { readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+import { short } from "./media.mjs";
+
+/** Pictures are fetched by the browser (page.request) and inlined, so the sheet needs no server. */
+export async function makeSheet(items, out, cols = 4) {
+  return orFail(
+    await inPage(
+      async (page, { items, out, cols }) => {
+        const cells = [];
+        for (const it of items) {
+          let src = it.data ?? "";
+          if (!src && it.src)
+            try {
+              const r = await page.request.get(it.src, { timeout: 30000 });
+              if (r.ok())
+                src = `data:${r.headers()["content-type"] ?? "image/jpeg"};base64,${(await r.body()).toString("base64")}`;
+            } catch {}
+          cells.push({ src, label: it.label });
+        }
+        const esc = (s) =>
+          String(s).replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
+        const html = `<!doctype html><meta charset="utf-8"><style>
+          body{margin:0;background:#fff;font:13px/1.35 system-ui,sans-serif;color:#111}
+          .grid{display:grid;grid-template-columns:repeat(${cols},240px);gap:10px;padding:10px}
+          .cell img,.cell .none{width:240px;height:300px;object-fit:contain;background:#e8e8e8;display:block}
+          .cell div{padding:3px 2px;height:36px;overflow:hidden}</style>
+          <div class="grid">${cells
+            .map(
+              (c) =>
+                `<div class="cell">${c.src ? `<img src="${c.src}">` : `<div class="none"></div>`}<div>${esc(c.label)}</div></div>`,
+            )
+            .join("")}</div>`;
+        const tab = await page.context().newPage();
+        try {
+          await tab.setViewportSize({ width: cols * 250 + 10, height: 400 });
+          await tab.setContent(html, { waitUntil: "load" });
+          await tab.screenshot({ path: out, fullPage: true, scale: "css" });
+        } finally {
+          await tab.close();
+        }
+        return { out, missing: cells.filter((c) => !c.src).length };
+      },
+      { items, out: resolve(out), cols },
+    ),
+  );
+}
+
+const MIME = {
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+const inline = (path) =>
+  `data:${MIME[extname(path).toLowerCase()] ?? "image/jpeg"};base64,${readFileSync(path).toString("base64")}`;
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const opts = parseArgs();
+  if (!opts.out || !opts._.length)
+    fail(
+      "usage: node sheet.mjs --out sheet.png <posts.json> [--post N] | <image url | file>...",
+    );
+  let items;
+  if (opts._[0].endsWith(".json")) {
+    const saved = JSON.parse(readFileSync(opts._[0], "utf8"));
+    const posts = saved.posts ?? saved;
+    if (opts.post) {
+      const p = posts[Number(opts.post) - 1];
+      if (!p) fail(`No post ${opts.post}; there are ${posts.length}.`);
+      items = p.images.map((src, i) => ({
+        src,
+        label: `${i + 1}/${p.images.length} ${p.ratio ?? ""}`,
+      }));
+    } else
+      items = posts.map((p, i) => ({
+        src: p.cover,
+        label: `#${i + 1} ${p.type}${p.type === "carousel" ? `×${p.slides}` : ""} ${p.ratio ?? ""} likes ${short(p.likes)}${p.owner ? ` @${p.owner}` : ""}`,
+      }));
+  } else
+    items = opts._.map((x, i) =>
+      /^https?:/.test(x)
+        ? { src: x, label: `${i + 1}` }
+        : { data: inline(x), label: `${i + 1} ${x.split("/").pop()}` },
+    );
+  const made = await makeSheet(items, opts.out, Number(opts.cols ?? 4));
+  console.log(
+    `${made.out} — ${items.length} pictures${made.missing ? `, ${made.missing} did not load` : ""}`,
+  );
+}

package/seed-skills/insta/instagram/scripts/webimage.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Saves the picture a web page shares itself with (og:image, else twitter:image),
+ * and with --all the large pictures in its body too, through the session's browser
+ * so a site that refuses curl still answers. Prints each file with its size and
+ * the credit line to put on the slide.
+ *
+ *   node webimage.mjs <page url> --out <dir> [--all] [--min 600]
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { imageSize } from "./image-size.mjs";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+
+const opts = parseArgs();
+const url = opts._[0];
+if (!url || !opts.out)
+  fail("usage: node webimage.mjs <page url> --out <dir> [--all] [--min 600]");
+const out = resolve(opts.out);
+mkdirSync(out, { recursive: true });
+
+const got = orFail(
+  await inPage(
+    async (page, { url, all, min }) => {
+      const res = await page.request.get(url, { timeout: 30000 });
+      const html = await res.text();
+      const meta = (key) => {
+        const tag = html.match(
+          new RegExp(`<meta[^>]+(?:property|name)=["']${key}["'][^>]*>`, "i"),
+        )?.[0];
+        return tag?.match(/content=["']([^"']+)["']/i)?.[1] ?? null;
+      };
+      const decode = (s) => s?.replace(/&amp;/g, "&").replace(/&#x2F;/g, "/");
+      // The VM has no URL class
+      const origin = url.match(/^https?:\/\/[^/]+/)[0];
+      const absolute = (src) =>
+        src.startsWith("//")
+          ? `https:${src}`
+          : src.startsWith("/")
+            ? origin + src
+            : src;
+      const site =
+        decode(meta("og:site_name")) ?? origin.replace(/^https?:\/\//, "");
+      const title =
+        decode(meta("og:title")) ?? html.match(/<title>([^<]*)/i)?.[1] ?? "";
+      const wanted = [decode(meta("og:image")) ?? decode(meta("twitter:image"))]
+        .filter(Boolean)
+        .map((src) => ({ src: absolute(src), alt: "og:image" }));
+      if (all) {
+        const tab = await page.context().newPage();
+        try {
+          await tab.goto(url, { waitUntil: "load", timeout: 45000 });
+          await tab.waitForTimeout(1500);
+          const found = await tab.evaluate(
+            (min) =>
+              [...document.images]
+                .filter((i) => i.naturalWidth >= min)
+                .map((i) => ({ src: i.currentSrc || i.src, alt: i.alt || "" })),
+            min,
+          );
+          for (const f of found)
+            if (!wanted.some((w) => w.src === f.src)) wanted.push(f);
+        } finally {
+          await tab.close();
+        }
+      }
+      const files = [];
+      for (const w of wanted.slice(0, 8)) {
+        try {
+          const r = await page.request.get(w.src, {
+            headers: { referer: url },
+            timeout: 30000,
+          });
+          if (!r.ok()) continue;
+          const type = r.headers()["content-type"] ?? "";
+          if (!type.startsWith("image/")) continue;
+          files.push({ ...w, type, data: (await r.body()).toString("base64") });
+        } catch {}
+      }
+      return { site, title, files, status: res.status() };
+    },
+    { url, all: Boolean(opts.all), min: Number(opts.min ?? 600) },
+  ),
+);
+
+if (!got.files.length)
+  fail(
+    `No picture came back from ${url} (page answered ${got.status}). Open it in the browser and take one from the page, or try --all.`,
+  );
+const ext = (type) =>
+  ({
+    "image/png": "png",
+    "image/webp": "webp",
+    "image/gif": "gif",
+    "image/avif": "avif",
+  })[type.split(";")[0]] ?? "jpg";
+got.files.forEach((f, i) => {
+  const path = `${out}/web-${String(i + 1).padStart(2, "0")}.${ext(f.type)}`;
+  writeFileSync(path, Buffer.from(f.data, "base64"));
+  const size = imageSize(path);
+  console.log(
+    `${path} ${size ? `${size.w}x${size.h}` : f.type} ${f.alt ? `(${f.alt.slice(0, 60)})` : ""}`,
+  );
+});
+console.log(`Credit: ${got.site} — ${got.title.trim().slice(0, 100)}`);

package/seed-skills/insta/instagram/templates/carousel.html

@@ -0,0 +1,62 @@
+<!doctype html>
+<!--
+  A carousel: every <section data-slide> is one PNG (scripts/render.mjs).
+  Set --w and --h to the size you render at. Pictures sit beside this file.
+  Backgrounds: .bg is the picture filling the slide; add .blur, .dark or a
+  .shade gradient over it until the text reads. .fit shows a whole picture
+  over a blurred copy of itself. .credit names the source of a real picture.
+-->
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@400;700;900&display=block">
+<style>
+  :root { --w: 1080px; --h: 1350px; --ink: #fff; --accent: #ffd400; --paper: #111; }
+  * { box-sizing: border-box; margin: 0; }
+  body { background: #000; font-family: "Noto Sans KR", "Apple SD Gothic Neo", system-ui, sans-serif; }
+  section[data-slide] {
+    position: relative; width: var(--w); height: var(--h); overflow: hidden;
+    background: var(--paper); color: var(--ink);
+  }
+  .bg, .fit img { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }
+  .bg.blur { filter: blur(24px) brightness(.7); transform: scale(1.1); }
+  .bg.dark { filter: brightness(.55); }
+  .shade { position: absolute; inset: 0; background: linear-gradient(180deg, rgba(0,0,0,0) 35%, rgba(0,0,0,.85) 100%); }
+  .fit .back { filter: blur(40px) brightness(.6); transform: scale(1.15); }
+  .fit .front { object-fit: contain; inset: 12% 6% 30%; width: 88%; height: 58%; }
+  .text { position: absolute; left: 72px; right: 72px; bottom: 120px; }
+  .kicker { font-size: 34px; font-weight: 700; color: var(--accent); margin-bottom: 20px; }
+  h1 { font-size: 92px; line-height: 1.12; font-weight: 900; letter-spacing: -0.02em; word-break: keep-all; }
+  p { font-size: 44px; line-height: 1.45; word-break: keep-all; }
+  .credit { position: absolute; left: 72px; bottom: 44px; font-size: 24px; opacity: .75; }
+  .page { position: absolute; right: 60px; top: 56px; font-size: 28px; opacity: .7; }
+</style>
+</head>
+<body>
+
+<section data-slide>
+  <img class="bg" src="photo.jpg" alt="">
+  <div class="shade"></div>
+  <div class="text">
+    <div class="kicker">NEWS</div>
+    <h1>The hook: one line that earns the swipe</h1>
+  </div>
+  <div class="credit">Photo: Source name</div>
+</section>
+
+<section data-slide>
+  <div class="fit"><img class="back" src="photo.jpg" alt=""><img class="front" src="photo.jpg" alt=""></div>
+  <div class="text"><p>A whole picture over a blurred copy of itself, with a line under it.</p></div>
+  <div class="page">2</div>
+</section>
+
+<section data-slide style="--paper: #f4f1ea; --ink: #111">
+  <div class="text" style="top: 160px; bottom: auto">
+    <h1 style="font-size: 72px">Text alone</h1>
+    <p style="margin-top: 40px">One idea a slide, large enough to read on a phone at arm's length.</p>
+  </div>
+  <div class="page">3</div>
+</section>
+
+</body>
+</html>

package/seed-skills/mail/mail/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: mail
+description: "Read and answer web mail by script instead of snapshots: list a search, read a thread into a file, save a draft or an in-thread reply. Gmail today; another site is one more recipe."
+---
+
+# Mail by script
+
+`scripts/mail.mjs` drives the browser this shell already has, so it rides whatever that browser
+is signed in to. Open it and load the sign-in first (`playwright-cli open`, then `sign_in_use`
+with `google.com`); the script goes to the page itself. Each command is one bash call and prints
+a few lines, never a page.
+
+```bash
+M="node <skill dir>/scripts/mail.mjs gmail"
+$M list [query] [--max N] [--json]   # Gmail search syntax; default in:inbox, 20, newest first
+$M unread [label] [--json]           # how many are unread, and the newest 20
+$M read <id> <file> [--head N]       # the whole thread as text into <file>; prints its head
+$M draft --to a@x.com[,b@y.com] [--cc …] --subject "…" --body-file <file>
+$M reply <id> --body-file <file> [--all]
+```
+
+A list line is `id * date | from <address> | subject (messages) — snippet`, `*` marking unread.
+`read` and `reply` take that id, or any message id from the thread.
+
+**What it costs.** `unread` and `read` are plain requests on the session's cookies and draw no
+page: about a second. `list`, `draft` and `reply` drive the Gmail app; the first loads it (5-8 s),
+later ones take 1-2 s. A snapshot of the inbox is about 140,000 characters; `list` of 20 is 7,000.
+
+**What marks mail read.** `list` and `unread` never do. `reply` opens the thread, which does.
+`read` on an unread thread may; when the snippet answers the question, leave it unread.
+
+**Nothing here sends.** `draft` and `reply` stop once Gmail has saved the draft, with the compose
+left open in this browser; Send is a separate click, and none of these commands make it.
+
+**An error is the answer.** `Layout changed: …` means the recipe no longer matches Gmail, never
+that there is no mail: fix it with [references/recipes.md](references/recipes.md). `Signed out`
+means load the sign-in again; if it still says so, the site ended the session.