synabun 1.3.0 → 2.0.0

package/mcp-server/src/tools/youtube/playlist.ts

@@ -0,0 +1,134 @@
+/**
+ * youtube_playlist — create a playlist, add a video to a playlist, or list
+ * playlists. Browser-driven through Studio (the Content → Playlists section and
+ * the video edit page's Playlists dropdown).
+ */
+
+import { z } from 'zod';
+import * as ni from '../../services/neural-interface.js';
+import { text } from '../response.js';
+import { STUDIO_BASE, resolve, ensureAuth, wait, pollFor, safeNavigate, clickStudio, fillStudio, DEEP_TEXT_SCRIPT, type Resolved } from './helpers.js';
+import { channelId } from './navigate.js';
+
+const tabId = z.string().optional().describe('Target a specific tab. Auto-resolved if omitted.');
+
+export const youtubePlaylistSchema = {
+  action: z.enum(['list', 'create', 'add'] as const).describe('list = enumerate playlists; create = make a new playlist; add = add a video to a playlist.'),
+  name: z.string().optional().describe('Playlist name (required for create/add).'),
+  videoId: z.string().optional().describe('Video id to add (required for action=add).'),
+  visibility: z.enum(['public', 'unlisted', 'private'] as const).optional().describe('New playlist visibility (create). Default public.'),
+  sessionId: z.string().optional(),
+  tabId,
+};
+
+export const youtubePlaylistDescription =
+  'Manage playlists. action=list enumerates them; action=create makes a new playlist; action=add adds a video to an existing playlist (by name). [mutating for create/add].';
+
+async function gotoPlaylists(r: Resolved): Promise<string | null> {
+  let cid = await channelId(r);
+  if (!cid) {
+    await safeNavigate(r, STUDIO_BASE);
+    await pollFor(r, `(() => /\\/channel\\/UC/.test(location.href) ? true : null)()`, 12000, 400);
+    cid = await channelId(r);
+  }
+  if (!cid) return 'Could not resolve the active channel.';
+  const nav = await safeNavigate(r, `${STUDIO_BASE}/channel/${cid}/playlists`);
+  if (nav.error) return `Navigation failed: ${nav.error}`;
+  const authErr = await ensureAuth(r);
+  if (authErr) return authErr;
+  await wait(1200);
+  return null;
+}
+
+export async function handleYoutubePlaylist(args: {
+  action: 'list' | 'create' | 'add';
+  name?: string;
+  videoId?: string;
+  visibility?: 'public' | 'unlisted' | 'private';
+  sessionId?: string;
+  tabId?: string;
+}) {
+  const r = await resolve(args.sessionId, args.tabId);
+  if ('error' in r) return text(r.error);
+
+  if (args.action === 'list') {
+    const err = await gotoPlaylists(r);
+    if (err) return text(err);
+    const res = await ni.evaluate(
+      r.sessionId,
+      `(() => {
+        const out = new Set();
+        const walk = (root) => {
+          if (!root) return;
+          root.querySelectorAll('*').forEach(el => { if (el.shadowRoot) walk(el.shadowRoot); });
+          root.querySelectorAll('#playlist-title, a#title, .playlist-title, [id="title"]').forEach(n => {
+            const t = (n.textContent || '').trim();
+            if (t && t.length < 120) out.add(t);
+          });
+        };
+        try { walk(document); } catch {}
+        return Array.from(out);
+      })()`,
+      r.tabId,
+    );
+    const names = (res.result as string[]) || [];
+    return text(JSON.stringify({ count: names.length, playlists: names }, null, 2));
+  }
+
+  if (args.action === 'create') {
+    if (!args.name) return text('name is required for action=create.');
+    const err = await gotoPlaylists(r);
+    if (err) return text(err);
+    const open = await clickStudio(r, '#create-playlist-button', 'New playlist');
+    if (!open.ok) {
+      const alt = await clickStudio(r, 'ytcp-button:has-text("New playlist")', 'New playlist');
+      if (!alt.ok) return text(`Could not open the New Playlist dialog: ${open.error}.`);
+    }
+    await wait(900);
+    const titled = await fillStudio(r, '#create-playlist-form #textbox', args.name, 'Title');
+    if (!titled.ok) {
+      await fillStudio(r, 'textarea#textbox', args.name, 'Title');
+    }
+    await wait(400);
+    // Visibility dropdown (optional — defaults to public).
+    if (args.visibility && args.visibility !== 'public') {
+      await clickStudio(r, '#visibility-select', 'Visibility');
+      await wait(400);
+      await clickStudio(r, `tp-yt-paper-item:has-text("${args.visibility}")`, args.visibility);
+      await wait(300);
+    }
+    const create = await clickStudio(r, '#create-button', 'Create');
+    if (!create.ok) return text(`Filled the playlist title but could not click Create: ${create.error}.`);
+    await wait(1000);
+    return text(JSON.stringify({ created: args.name, visibility: args.visibility || 'public' }, null, 2));
+  }
+
+  // action === 'add'
+  if (!args.name || !args.videoId) return text('name and videoId are required for action=add.');
+  const nav = await safeNavigate(r, `${STUDIO_BASE}/video/${args.videoId}/edit`);
+  if (nav.error) return text(`Navigation failed: ${nav.error}`);
+  const authErr = await ensureAuth(r);
+  if (authErr) return text(authErr);
+  const ready = await ni.waitFor(r.sessionId, { selector: '#title-textarea', state: 'visible', timeout: 20000 }, r.tabId);
+  if (ready.error) return text(`Edit page did not load: ${ready.error}`);
+  await wait(600);
+
+  const open = await clickStudio(r, '#playlists-dropdown-trigger', 'Playlists');
+  if (!open.ok) {
+    const alt = await clickStudio(r, 'ytcp-text-dropdown-trigger:has-text("Playlists")', 'Playlists');
+    if (!alt.ok) return text(`Could not open the Playlists dropdown: ${open.error}.`);
+  }
+  await wait(900);
+  // Check the playlist by name.
+  const check = await clickStudio(r, `ytcp-checkbox-group #items tp-yt-paper-checkbox:has-text("${args.name}")`, args.name);
+  if (!check.ok) {
+    const alt = await clickStudio(r, `tp-yt-paper-checkbox:has-text("${args.name}")`, args.name);
+    if (!alt.ok) return text(`Could not find playlist "${args.name}" in the dropdown. Create it first with action=create.`);
+  }
+  await wait(400);
+  await clickStudio(r, '.done-button, #done-button', 'Done');
+  await wait(400);
+  const save = await clickStudio(r, '#save', 'Save');
+  void DEEP_TEXT_SCRIPT; // (reserved for richer confirmation parsing)
+  return text(JSON.stringify({ videoId: args.videoId, addedTo: args.name, saved: save.ok }, null, 2));
+}

package/mcp-server/src/tools/youtube/schedule.ts

@@ -0,0 +1,158 @@
+/**
+ * youtube_schedule — set a future publish time (or change visibility) on a video
+ * via the Studio edit page's visibility dialog. Lets the autopilot drip trailers
+ * out instead of publishing them all at once.
+ *
+ * Date/time entry is locale-aware: this channel runs in America/Sao_Paulo (pt-BR
+ * Studio uses DD/MM/AAAA + 24h), so we pick the field format from the page locale
+ * and read the picker back so a mis-parsed date is visible, not silent.
+ */
+
+import { z } from 'zod';
+import * as ni from '../../services/neural-interface.js';
+import { text } from '../response.js';
+import { STUDIO_BASE, resolve, ensureAuth, wait, pollFor, safeNavigate, clickStudio, fillStudio } from './helpers.js';
+
+const tabId = z.string().optional().describe('Target a specific tab. Auto-resolved if omitted.');
+
+export const youtubeScheduleSchema = {
+  videoId: z.string().describe('YouTube video id.'),
+  publishAt: z.string().optional().describe('Scheduled publish time, ISO ("2026-06-20T18:00") or "YYYY-MM-DD HH:MM". Required unless setting an immediate visibility.'),
+  visibility: z.enum(['private', 'unlisted', 'public', 'schedule'] as const).optional().describe('Set immediate visibility, or "schedule" (default when publishAt is given).'),
+  sessionId: z.string().optional(),
+  tabId,
+};
+
+export const youtubeScheduleDescription =
+  'Schedule a video to go public at a future time (or set immediate visibility) via the Studio visibility dialog. ' +
+  'Pass publishAt for scheduling. [mutating]. Locale-aware date entry (US + pt-BR); the response echoes the picker read-back as scheduledDisplay — verify it matches your intended slot.';
+
+type DateTimeFormats = { dateUS: string; dateBR: string; time12: string; time24: string };
+
+function buildDateTimeFormats(publishAt: string): DateTimeFormats | null {
+  // Accept ISO or "YYYY-MM-DD HH:MM".
+  const m = publishAt.match(/(\d{4})-(\d{2})-(\d{2})[T ](\d{1,2}):(\d{2})/);
+  if (!m) return null;
+  const [, y, mo, d, hh, mm] = m;
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const dateUS = `${months[parseInt(mo, 10) - 1]} ${parseInt(d, 10)}, ${y}`; // "Jun 20, 2026"
+  const dateBR = `${d}/${mo}/${y}`; // "20/06/2026"
+  let h = parseInt(hh, 10);
+  const ampm = h >= 12 ? 'PM' : 'AM';
+  h = h % 12; if (h === 0) h = 12;
+  const time12 = `${h}:${mm} ${ampm}`; // "2:00 PM"
+  const time24 = `${hh.padStart(2, '0')}:${mm}`; // "14:00"
+  return { dateUS, dateBR, time12, time24 };
+}
+
+export async function handleYoutubeSchedule(args: {
+  videoId: string;
+  publishAt?: string;
+  visibility?: 'private' | 'unlisted' | 'public' | 'schedule';
+  sessionId?: string;
+  tabId?: string;
+}) {
+  const wantsSchedule = args.visibility === 'schedule' || (!!args.publishAt && !args.visibility);
+  if (wantsSchedule && !args.publishAt) return text('publishAt is required to schedule a video.');
+
+  const r = await resolve(args.sessionId, args.tabId);
+  if ('error' in r) return text(r.error);
+
+  const nav = await safeNavigate(r, `${STUDIO_BASE}/video/${args.videoId}/edit`);
+  if (nav.error) return text(`Navigation failed: ${nav.error}`);
+  const authErr = await ensureAuth(r);
+  if (authErr) return text(authErr);
+  const ready = await ni.waitFor(r.sessionId, { selector: '#title-textarea', state: 'visible', timeout: 20000 }, r.tabId);
+  if (ready.error) return text(`Edit page did not load: ${ready.error}`);
+  await wait(600);
+
+  // Detect the Studio UI language once (this channel runs pt-BR) so the element
+  // fallbacks and date formats below use the right text hints.
+  const langRes = await ni.evaluate(r.sessionId, `((document.documentElement && document.documentElement.lang) || navigator.language || '').toLowerCase()`, r.tabId);
+  const isPt = String(langRes.result || '').startsWith('pt');
+
+  // Open the visibility dialog (stable id → component → text fallback, for pt-BR Studio).
+  let openVis = await clickStudio(r, '#visibility-container', isPt ? 'Visibilidade' : 'Visibility');
+  if (!openVis.ok) openVis = await clickStudio(r, 'ytcp-video-visibility-select', isPt ? 'Visibilidade' : 'Visibility');
+  if (!openVis.ok) openVis = await clickStudio(r, 'ytcp-video-metadata-visibility, #visibility-button', isPt ? 'Visibilidade' : 'Visibility');
+  if (!openVis.ok) return text(`Could not open the visibility dialog: ${openVis.error}. Open it manually in the browser panel, then retry.`);
+  await wait(900);
+
+  let scheduledDisplay: string | null = null;
+  let localeUsed: 'pt' | 'us' | undefined;
+
+  if (wantsSchedule) {
+    // Select Schedule (stable name= → class → text fallback, for pt-BR Studio
+    // where the radio is sometimes replaced by an "Agendar" button).
+    let sched = await clickStudio(r, 'tp-yt-paper-radio-button[name="SCHEDULE"]', isPt ? 'Agendar' : 'Schedule');
+    if (!sched.ok) sched = await clickStudio(r, 'ytcp-button[class*="Schedule"], [test-id="SCHEDULE"]', isPt ? 'Agendar' : 'Schedule');
+    if (!sched.ok) sched = await clickStudio(r, '[name="SCHEDULE"]', isPt ? 'Agendar' : 'Schedule');
+    if (!sched.ok) return text(`Could not select the Schedule option: ${sched.error}. Set it manually in the browser panel.`);
+    await wait(700);
+    const dt = buildDateTimeFormats(args.publishAt!);
+    if (!dt) return text(`Could not parse publishAt "${args.publishAt}". Use ISO or "YYYY-MM-DD HH:MM".`);
+
+    // Pick the field format from the page locale (pt-BR → DD/MM/AAAA + 24h).
+    localeUsed = isPt ? 'pt' : 'us';
+    const dateStr = isPt ? dt.dateBR : dt.dateUS;
+    const timeStr = isPt ? dt.time24 : dt.time12;
+
+    // Date picker.
+    await clickStudio(r, '#datepicker-trigger', 'Date');
+    await wait(400);
+    await fillStudio(r, '#datepicker-trigger #textbox', dateStr, 'Date');
+    await ni.pressKey(r.sessionId, 'Enter', r.tabId);
+    await wait(400);
+    // Time field.
+    await fillStudio(r, 'ytcp-datetime-picker #time-of-day-container #textbox', timeStr, 'Time');
+    await ni.pressKey(r.sessionId, 'Enter', r.tabId);
+    await wait(400);
+
+    // Read the picker back (shadow-pierced) so a mis-parsed date is visible.
+    const rb = await ni.evaluate(
+      r.sessionId,
+      `(() => {
+        const out = [];
+        const walk = (root) => {
+          if (!root) return;
+          root.querySelectorAll('*').forEach((el) => { if (el.shadowRoot) walk(el.shadowRoot); });
+          root.querySelectorAll('#datepicker-trigger, ytcp-datetime-picker').forEach((n) => {
+            const t = (n.innerText || '').replace(/\\s+/g, ' ').trim();
+            if (t) out.push(t);
+          });
+        };
+        try { walk(document); } catch {}
+        return out.join(' | ').slice(0, 160) || null;
+      })()`,
+      r.tabId,
+    );
+    scheduledDisplay = (rb.result as string | null) || null;
+  } else {
+    const vis = (args.visibility || 'private').toUpperCase();
+    const ok = await clickStudio(r, `tp-yt-paper-radio-button[name="${vis}"]`, vis.charAt(0) + vis.slice(1).toLowerCase());
+    if (!ok.ok) return text(`Could not select visibility ${vis}: ${ok.error}.`);
+    await wait(400);
+  }
+
+  // Save (the visibility dialog's Done/Save).
+  const save = await clickStudio(r, '#save-button', wantsSchedule ? 'Schedule' : 'Save');
+  if (!save.ok) {
+    const alt = await clickStudio(r, '#done-button', 'Done');
+    if (!alt.ok) return text(`Set the visibility but could not confirm/Save: ${save.error}. Confirm in the browser panel.`);
+  }
+  // Locale-tolerant confirm: match the success stems across en + pt-BR.
+  const done = await pollFor(r, `(() => /Scheduled|Agendad|Programad|Published|Publicad|saved|Salv/i.test(document.body.innerText) ? true : null)()`, 12000, 500);
+
+  return text(JSON.stringify({
+    videoId: args.videoId,
+    action: wantsSchedule ? 'scheduled' : 'visibility',
+    publishAt: wantsSchedule ? args.publishAt : undefined,
+    visibility: wantsSchedule ? 'scheduled→public' : (args.visibility || 'private'),
+    localeUsed,
+    scheduledDisplay,
+    confirmed: !!done,
+    note: wantsSchedule
+      ? 'Verify scheduledDisplay matches your intended slot — if the day/month look swapped, the channel locale differs from what was detected; re-run with the date pre-formatted for that locale or fix it in the panel.'
+      : undefined,
+  }, null, 2));
+}

package/mcp-server/src/tools/youtube/source.ts

@@ -0,0 +1,101 @@
+/**
+ * youtube_source — discover candidate game trailers via YouTube search, IGDB
+ * (metadata + Steam appid + YouTube trailer ids), and Steam (direct mp4 URLs).
+ * Delegates to the Neural Interface /api/sources/discover endpoint, which holds
+ * the credentials.
+ *
+ * Dedup is built in: candidates already on the `youtube-videos` memory ledger
+ * (written by youtube_upload) are dropped before they reach the model, and the
+ * returned payload is trimmed to the fields the pipeline actually needs — so
+ * each autopilot iteration spends a fraction of the tokens the old
+ * recall-then-eyeball flow did, and can never re-pick a posted trailer.
+ */
+
+import { z } from 'zod';
+import * as ni from '../../services/neural-interface.js';
+import { getPostedTrailerKeys } from '../../services/sqlite.js';
+import { candidateDedupKeys } from './dedup.js';
+import { text } from '../response.js';
+
+export const youtubeSourceSchema = {
+  source: z.enum(['auto', 'igdb', 'steam', 'youtube'] as const).optional().describe(
+    "Discovery backend. 'youtube' = YouTube Data API date-ordered recent trailer search; 'auto' (default) = IGDB games enriched with Steam mp4 URLs; 'igdb' = metadata + trailer pointers only; 'steam' = resolve explicit appids.",
+  ),
+  query: z.string().optional().describe('Game title or trailer search query. For source=youtube, omit to search official game trailers by publish date.'),
+  appids: z.array(z.number()).optional().describe('Steam appids to resolve (required for source=steam).'),
+  limit: z.number().optional().describe('Max candidates (1-50, default 10).'),
+  lookbackDays: z.number().optional().describe('For source=youtube: published-after window. For IGDB/auto: release-date lookback window (default from config / 60).'),
+  excludePosted: z.boolean().optional().describe('Drop trailers already on the youtube-videos memory ledger (exact igdb/appid/ytid/name match). Default true — leave it on so the autopilot never re-posts. Set false only to inspect the raw pool.'),
+};
+
+export const youtubeSourceDescription =
+  'Discover FRESH candidate game trailers (already-posted ones are removed automatically via the youtube-videos memory ledger — no manual dedup/recall needed). ' +
+  'Searches YouTube for recently published trailers, queries IGDB for games (+ Steam appid and official YouTube trailer ids), and resolves Steam direct mp4 URLs. ' +
+  'Returns trimmed candidates: { game, source, igdbId, appid, releaseDate, trailerPublishedAt, trailerTitle, genres, ytTrailerIds, steamMp4Url, summary }. ' +
+  'Feed one to youtube_download (prefer steamMp4Url; fall back to a ytTrailerIds value), then pass its game/igdbId/appid/sourceTrailerId back into youtube_upload so it records the ledger.';
+
+/** Keep only the fields the download/metadata/upload steps use — drop cover, webm, thumbnails, channelTitle, and the full steamMovies[] blob (big token savers). */
+function trimCandidate(c: Record<string, unknown>) {
+  const movies = Array.isArray(c.steamMovies) ? (c.steamMovies as Array<Record<string, unknown>>) : [];
+  const steamMp4Url = (movies.find((m) => typeof m?.mp4 === 'string')?.mp4 as string) || null;
+  const summary = typeof c.summary === 'string' ? c.summary.slice(0, 240) : undefined;
+  return {
+    game: c.game ?? null,
+    source: c.source ?? undefined,
+    igdbId: c.igdbId ?? null,
+    appid: c.appid ?? null,
+    releaseDate: c.releaseDate ?? null,
+    trailerPublishedAt: c.trailerPublishedAt ?? undefined,
+    trailerTitle: c.trailerTitle ?? undefined,
+    genres: Array.isArray(c.genres) && c.genres.length ? c.genres : undefined,
+    ytTrailerIds: Array.isArray(c.ytTrailerIds) ? c.ytTrailerIds : [],
+    steamMp4Url,
+    watchUrl: c.url ?? undefined,
+    summary,
+  };
+}
+
+export async function handleYoutubeSource(args: {
+  source?: 'auto' | 'igdb' | 'steam' | 'youtube';
+  query?: string;
+  appids?: number[];
+  limit?: number;
+  lookbackDays?: number;
+  excludePosted?: boolean;
+}) {
+  const r = await ni.youtubeDiscover({
+    source: args.source,
+    query: args.query,
+    appids: args.appids,
+    limit: args.limit,
+    filters: args.lookbackDays !== undefined ? { lookbackDays: args.lookbackDays } : undefined,
+  });
+  if (r.error) return text(`Discovery failed: ${r.error}`);
+
+  let candidates = ((r.candidates as Array<Record<string, unknown>>) || []);
+  const discovered = candidates.length;
+
+  // Dedup: drop anything already on the ledger (default on).
+  let filtered = 0;
+  if (args.excludePosted !== false && candidates.length) {
+    const posted = getPostedTrailerKeys();
+    if (posted.size) {
+      candidates = candidates.filter((c) => {
+        const dup = candidateDedupKeys(c).some((k) => posted.has(k));
+        if (dup) filtered++;
+        return !dup;
+      });
+    }
+  }
+
+  if (candidates.length === 0) {
+    if (filtered > 0) {
+      return text(`No fresh candidates — all ${discovered} discovered trailers are already on the youtube-videos ledger. Broaden the query/lookback, try source:auto, or (to inspect) call again with excludePosted:false.`);
+    }
+    const diag = r.diagnostic as string | undefined;
+    return text(diag ? `No candidates found. ${diag}` : 'No candidates found. Check IGDB credentials in Settings → YouTube, or broaden the query/lookback.');
+  }
+
+  const trimmed = candidates.map(trimCandidate);
+  return text(JSON.stringify({ count: trimmed.length, filteredAlreadyPosted: filtered, candidates: trimmed }, null, 2));
+}