vidspotai-shared 1.0.95 → 1.0.97

package/lib/services/demo/demoScriptWriter.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDemoScript = writeDemoScript;
+exports.normalizeDemoScript = normalizeDemoScript;
+const zod_1 = require("zod");
+const llmCallerRegistry_1 = require("../agent/llmCallerRegistry");
+const modelRouter_1 = require("../agent/modelRouter");
+const demoScriptPrompt_1 = require("./demoScriptPrompt");
+/**
+ * DemoSpec narration writer — the "script" stage of the SaaS Demo Video pipeline
+ * (plan Phase 5 / §4 stage 4 / §6).
+ *
+ * ONE Claude `.structured()` call turns the already-rendered DemoSpec timeline
+ * into a per-scene, timeline-synced narration script. Because the scene durations
+ * are fixed by the time this runs, every segment's `startMs` is deterministic
+ * (cumulative scene offset) and its window is the scene's own duration — no
+ * recording analysis, no timestamp guessing. The voice stage (worker) then
+ * TTS-synthesises each segment and speed-fits it to the window.
+ *
+ * Mirrors `authorDemoSpec`: provider-agnostic (injected `LlmCaller`),
+ * model-routed, hardened by a deterministic normalize pass that enforces the
+ * invariants the prompt can only request (valid sceneIds, one segment per scene,
+ * timeline order + offsets).
+ */
+/** LLM output contract — the model returns raw per-scene lines; we compute timing. */
+const DemoScriptDraftSchema = zod_1.z.object({
+    segments: zod_1.z
+        .array(zod_1.z.object({
+        /** Must match a DemoScene.id from the spec. */
+        sceneId: zod_1.z.string(),
+        /** Spoken narration for the scene (empty ⇒ scene left silent). */
+        text: zod_1.z.string(),
+    }))
+        .default([]),
+});
+/**
+ * Write a timeline-synced narration script for a rendered DemoSpec. Pure
+ * orchestration: build the per-scene briefs, call `.structured()`, then normalize
+ * to concrete `IDemoVideoScriptSegment[]` (compute offsets, drop unknown/empty
+ * scenes, dedupe, order). Returns an empty `segments` list (not a throw) when the
+ * model narrates nothing — the caller decides whether that means "silent final".
+ */
+async function writeDemoScript(spec, deps = {}) {
+    const llm = deps.llm ?? (0, llmCallerRegistry_1.getLlmCaller)();
+    const router = deps.router ?? new modelRouter_1.ModelRouter();
+    const model = router.pickFor("planner", { premium: deps.premium });
+    const fallbackModel = router.fallbackFor("planner");
+    const briefs = (0, demoScriptPrompt_1.buildDemoScriptBriefs)(spec);
+    const system = (0, demoScriptPrompt_1.buildDemoScriptSystemPrompt)();
+    const userText = (0, demoScriptPrompt_1.buildDemoScriptUserText)(spec, briefs);
+    const result = await llm.structured({
+        model,
+        fallbackModel,
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: userText },
+        ],
+        schema: DemoScriptDraftSchema,
+        schemaName: "DemoScript",
+        temperature: deps.temperature ?? 0.6,
+        maxTokens: deps.maxTokens ?? 2000,
+    });
+    const draft = DemoScriptDraftSchema.parse(result.data);
+    let { segments, adjustments } = normalizeDemoScript(spec, draft.segments);
+    let usedHintFallback = false;
+    // Robustness: the dedicated writer has been observed to return ZERO usable
+    // segments (empty array, or ids that all drop) even when the author gave a
+    // per-scene `narrationHint`. For a voiceover/captions video that silently
+    // ships a SILENT final (the worker skips voice/mux when segments is empty) —
+    // a whiff on one LLM call shouldn't strip a video's intended narration. Fall
+    // back to the authored hints (already scene-appropriate spoken intent) run
+    // through the same normalize path. Music-led videos are left silent as before.
+    if (segments.length === 0 && spec.style.audioIntent !== "music") {
+        const hintSegments = spec.scenes
+            .filter((s) => (s.narrationHint ?? "").trim().length > 0)
+            .map((s) => ({ sceneId: s.id, text: s.narrationHint.trim() }));
+        if (hintSegments.length > 0) {
+            const fromHints = normalizeDemoScript(spec, hintSegments);
+            segments = fromHints.segments;
+            adjustments = [
+                ...adjustments,
+                `script writer returned no usable segments — fell back to ${segments.length} authored narrationHint(s)`,
+                ...fromHints.adjustments,
+            ];
+            usedHintFallback = segments.length > 0;
+        }
+    }
+    return {
+        segments,
+        adjustments,
+        modelUsed: result.usedFallback && fallbackModel ? fallbackModel : model,
+        usedFallback: result.usedFallback,
+        usedHintFallback,
+        usage: result.usage,
+    };
+}
+/** Lowercase + strip non-alphanumerics — collapses id/type spelling drift. */
+function normalizeIdKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/**
+ * Deterministic guarantees the prompt can only request:
+ *  - resolve each segment to a REAL scene (drop truly unknown sceneIds),
+ *  - one segment per scene (keep the first; drop later duplicates),
+ *  - drop blank narration,
+ *  - stamp `startMs` (cumulative scene offset) + `durationMs` (the scene window;
+ *    the voice stage overwrites `durationMs` with the actual spoken length),
+ *  - emit in timeline order.
+ *
+ * `sceneId` resolution is tolerant by design. The script LLM is a separate call
+ * from the planner and has been observed to echo the scene *type* (`logoReveal`,
+ * `problem`, …) or a punctuation-drifted slug instead of the planner's exact
+ * `scene.id`. Rather than drop every segment (which silently ships a captionless,
+ * voiceover-less video), we resolve a raw id in three tiers: exact id → id with
+ * spelling drift normalized → the scene *type* when that type occurs exactly once
+ * in the timeline (so the mapping is unambiguous). Only a raw id that matches
+ * none of these is dropped. Each non-exact resolution is recorded as an
+ * adjustment for observability.
+ */
+function normalizeDemoScript(spec, rawSegments) {
+    const adjustments = [];
+    // Scene id → { startMs, durationMs, order } by walking the timeline once, plus
+    // fallback lookup tables (normalized id, and type→id only when the type is
+    // unique so the resolution is unambiguous).
+    const sceneWindows = new Map();
+    const byNormalizedId = new Map();
+    const typeCount = new Map();
+    const firstIdOfType = new Map();
+    let offset = 0;
+    spec.scenes.forEach((scene, order) => {
+        sceneWindows.set(scene.id, { startMs: offset, durationMs: scene.durationMs, order });
+        offset += scene.durationMs;
+        byNormalizedId.set(normalizeIdKey(scene.id), scene.id);
+        typeCount.set(scene.type, (typeCount.get(scene.type) ?? 0) + 1);
+        if (!firstIdOfType.has(scene.type))
+            firstIdOfType.set(scene.type, scene.id);
+    });
+    // type (and normalized type) → id, only for types that appear exactly once.
+    const uniqueTypeToId = new Map();
+    for (const [type, count] of typeCount) {
+        if (count !== 1)
+            continue;
+        const id = firstIdOfType.get(type);
+        if (!id)
+            continue;
+        uniqueTypeToId.set(type, id);
+        uniqueTypeToId.set(normalizeIdKey(type), id);
+    }
+    /** Resolve a raw sceneId to a real scene id, or null if unresolvable. */
+    const resolve = (rawId) => {
+        if (sceneWindows.has(rawId))
+            return { id: rawId };
+        const key = normalizeIdKey(rawId);
+        const byId = byNormalizedId.get(key);
+        if (byId && byId !== rawId) {
+            return { id: byId, note: `resolved sceneId "${rawId}" → "${byId}" (spelling drift)` };
+        }
+        const byType = uniqueTypeToId.get(rawId) ?? uniqueTypeToId.get(key);
+        if (byType) {
+            return { id: byType, note: `resolved sceneId "${rawId}" → "${byType}" (matched unique scene type)` };
+        }
+        return null;
+    };
+    const seen = new Set();
+    const segments = [];
+    for (const raw of rawSegments) {
+        const text = (raw.text ?? "").trim();
+        const resolved = resolve(raw.sceneId);
+        if (!resolved) {
+            adjustments.push(`dropped segment for unknown sceneId "${raw.sceneId}"`);
+            continue;
+        }
+        const window = sceneWindows.get(resolved.id);
+        if (!window) {
+            // Unreachable (resolve only returns known ids) but keeps the type honest.
+            adjustments.push(`dropped segment for unknown sceneId "${raw.sceneId}"`);
+            continue;
+        }
+        if (!text) {
+            // An explicit empty line = "leave this scene silent"; not an error.
+            continue;
+        }
+        if (seen.has(resolved.id)) {
+            adjustments.push(`dropped duplicate segment for sceneId "${resolved.id}"`);
+            continue;
+        }
+        seen.add(resolved.id);
+        if (resolved.note)
+            adjustments.push(resolved.note);
+        // Hard-enforce the spoken-word budget the prompt only *asked* for: an
+        // over-budget line (the writer overshoots ~2×) is deterministically trimmed
+        // to fit the scene window, so the synthesized voice never overruns into the
+        // next scene (the overlapping-voices defect) or gets clipped/rushed by the
+        // voice stage. This is the correct-by-construction half of the no-overlap
+        // guarantee — the voice-stage atempo net now only ever handles minor residue.
+        const budget = (0, demoScriptPrompt_1.scriptWordBudget)(window.durationMs);
+        const fitted = (0, demoScriptPrompt_1.fitNarrationToBudget)(text, budget);
+        if (fitted.trimmed) {
+            adjustments.push(`trimmed narration for "${resolved.id}" to fit its ${Math.round(window.durationMs / 1000)}s window (${(0, demoScriptPrompt_1.wordCount)(text)}→${(0, demoScriptPrompt_1.wordCount)(fitted.text)} words, budget ${budget})`);
+        }
+        segments.push({
+            sceneId: resolved.id,
+            text: fitted.text,
+            startMs: window.startMs,
+            durationMs: window.durationMs,
+        });
+    }
+    // Timeline order — the model is asked for order but we don't rely on it.
+    segments.sort((a, b) => (sceneWindows.get(a.sceneId).order - sceneWindows.get(b.sceneId).order));
+    return { segments, adjustments };
+}

package/lib/services/demo/demoTriage.d.ts

@@ -0,0 +1,65 @@
+import { LlmCaller } from "../agent/llmCaller";
+import { ModelChoice, ModelRouter } from "../agent/modelRouter";
+import { DemoTriageResult } from "../../schemas/demoQuestion.schema";
+/**
+ * SaaS Demo Video Generator — DYNAMIC clarification triage (plan §clarification).
+ *
+ * The wizard's fixed §2.6 style/pace questions cover the GENERIC axes. This adds
+ * the PRODUCT-SPECIFIC layer the user asked for: after the initial read of the
+ * website + the details they gave, a cheap Haiku pass decides whether a few
+ * targeted questions would MATERIALLY improve the video — and, only if so, what to
+ * ask. A clear, complete brief returns `ask:false` (no questions, just generate).
+ *
+ * ONE contract (`DemoQuestion`) powers BOTH surfaces:
+ *   - PRE-GEN: the /triage endpoint calls this before any spend; the wizard renders
+ *     the questions inline; answers ride the create call as `clarifyAnswers`.
+ *   - MID-RUN: the worker can call this at an ambiguity point and pause.
+ *
+ * Fail-soft everywhere: any error / unconfigured LLM ⇒ `{ ask:false }`, so
+ * clarification never blocks generation. Uncharged (a Haiku call over a short
+ * brief is negligible, exactly like demoPrefill).
+ */
+/** What we know about the product at triage time (from the wizard + autofill). */
+export interface DemoTriageContext {
+    productName: string;
+    tagline?: string;
+    description?: string;
+    audience?: string;
+    websiteUrl?: string;
+    /** Presence of each input source — lets triage ask to fill a gap. */
+    hasWebsite: boolean;
+    hasGithub: boolean;
+    hasScreenshots: boolean;
+    /** Featured media the user attached (drives "how should we use this clip?" questions). */
+    mediaAssets?: Array<{
+        kind: "image" | "video";
+        label?: string;
+    }>;
+    /** Features the user already listed to highlight. */
+    features?: string[];
+    /**
+     * Which fixed §2.6 axes the user ALREADY pinned (true = pinned, not "decide for
+     * me"). Triage must NOT re-ask a pinned axis — it complements, never duplicates,
+     * the static wizard.
+     */
+    pinned?: Partial<Record<"visualStyle" | "pace" | "targetLength" | "narrative" | "aspect" | "colorMood" | "audioIntent", boolean>>;
+    /** Optional extra page/summary signal (e.g. from the gather stage) to ground questions. */
+    pageSummary?: string;
+}
+export interface DemoTriageDeps {
+    llm?: LlmCaller;
+    router?: ModelRouter;
+}
+export interface DemoTriageOutcome extends DemoTriageResult {
+    modelUsed?: ModelChoice;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+    };
+}
+/**
+ * Run the triage pass. Returns `{ ask, reason, questions }`. Never throws — an
+ * unconfigured/erroring LLM degrades to `{ ask:false }` so generation proceeds.
+ */
+export declare function triageDemoClarifications(ctx: DemoTriageContext, deps?: DemoTriageDeps): Promise<DemoTriageOutcome>;
+//# sourceMappingURL=demoTriage.d.ts.map

package/lib/services/demo/demoTriage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demoTriage.d.ts","sourceRoot":"","sources":["../../../src/services/demo/demoTriage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAEL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AAEH,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjE,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CACd,MAAM,CACF,aAAa,GACb,MAAM,GACN,cAAc,GACd,WAAW,GACX,QAAQ,GACR,WAAW,GACX,aAAa,EACf,OAAO,CACR,CACF,CAAC;IACF,2FAA2F;IAC3F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACzD,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,KAAK,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAmFD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,iBAAiB,EACtB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,iBAAiB,CAAC,CAgC5B"}

package/lib/services/demo/demoTriage.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triageDemoClarifications = triageDemoClarifications;
+const llmCallerRegistry_1 = require("../agent/llmCallerRegistry");
+const modelRouter_1 = require("../agent/modelRouter");
+const demoQuestion_schema_1 = require("../../schemas/demoQuestion.schema");
+const NO_QUESTIONS = { ask: false, questions: [] };
+function buildTriageSystem() {
+    return [
+        "You are the intake specialist for an autonomous SaaS product-demo VIDEO generator.",
+        "Given what we already know about a product, decide whether asking the user a FEW",
+        "targeted clarifying questions would MATERIALLY improve the generated video.",
+        "",
+        "Ask ONLY when it genuinely helps. If the brief is already clear and complete,",
+        "return ask=false with no questions — never ask for the sake of asking. Most",
+        "well-described products need ZERO questions.",
+        "",
+        "Good reasons to ask (max 3, ideally 1–2 questions):",
+        "- The product's core value or primary user flow is ambiguous from what's given.",
+        "- The user attached video/image assets but didn't say how to feature them.",
+        "- Which specific features to spotlight is unclear and there are clearly several.",
+        "- A concrete creative fork that changes the video and isn't already decided",
+        "  (e.g. 'lead with the problem or the product?', 'show real UI or stylized?').",
+        "",
+        "NEVER ask:",
+        "- Anything already provided or already pinned by the user (you'll be told which).",
+        "- The generic style/pace/length/aspect/color/audio axes — a separate UI covers",
+        "  those; only ask about them if a pinned value conflicts with the product.",
+        "- Anything you can reasonably infer yourself — you are meant to be autonomous.",
+        "",
+        "Question kinds (use the simplest that fits):",
+        '- single: pick one option. Fields: kind,id,prompt,help?,options[{value,label,description?}],allowOther?,required?',
+        "- multi: pick several. Same as single plus min?/max?.",
+        '- toggle: a yes/no. Fields: kind,id,prompt,help?,default,onLabel?,offLabel?.',
+        '- text: a short typed answer. Fields: kind,id,prompt,help?,placeholder?,multiline?,maxLength?.',
+        "",
+        "Rules: give every question a short stable snake_case id. Keep prompts under ~14",
+        "words. Provide 2–5 concrete options for single/multi. Mark a question required",
+        "only if the video truly can't proceed without it (rare — prefer optional).",
+        "Return valid JSON matching the schema.",
+    ].join("\n");
+}
+function buildTriageUser(ctx) {
+    const lines = [];
+    lines.push(`Product name: ${ctx.productName}`);
+    if (ctx.tagline)
+        lines.push(`Tagline: ${ctx.tagline}`);
+    if (ctx.description)
+        lines.push(`Description: ${ctx.description}`);
+    if (ctx.audience)
+        lines.push(`Audience: ${ctx.audience}`);
+    if (ctx.websiteUrl)
+        lines.push(`Website: ${ctx.websiteUrl}`);
+    if (ctx.features?.length)
+        lines.push(`Features to highlight: ${ctx.features.join(", ")}`);
+    const sources = [];
+    if (ctx.hasWebsite)
+        sources.push("website");
+    if (ctx.hasGithub)
+        sources.push("github repo");
+    if (ctx.hasScreenshots)
+        sources.push("screenshots");
+    lines.push(`Input sources available: ${sources.length ? sources.join(", ") : "none beyond the text above"}`);
+    if (ctx.mediaAssets?.length) {
+        const summary = ctx.mediaAssets
+            .map((a) => `${a.kind}${a.label ? ` ("${a.label}")` : ""}`)
+            .join(", ");
+        lines.push(`Featured media the user attached (must appear IN the video): ${summary}.`, "If it's unclear where/how to use these, that is a good thing to ask about.");
+    }
+    const pinned = Object.entries(ctx.pinned ?? {})
+        .filter(([, v]) => v)
+        .map(([k]) => k);
+    lines.push(`Already decided by the user (do NOT ask about these): ${pinned.length ? pinned.join(", ") : "none"}.`);
+    if (ctx.pageSummary) {
+        lines.push("", "Extra signal from the site:", ctx.pageSummary.slice(0, 1500));
+    }
+    lines.push("", "Decide: ask=true with 1–3 high-value questions, or ask=false if the brief is clear.");
+    return lines.join("\n");
+}
+/**
+ * Run the triage pass. Returns `{ ask, reason, questions }`. Never throws — an
+ * unconfigured/erroring LLM degrades to `{ ask:false }` so generation proceeds.
+ */
+async function triageDemoClarifications(ctx, deps = {}) {
+    const llm = deps.llm ?? (0, llmCallerRegistry_1.getLlmCaller)();
+    const router = deps.router ?? new modelRouter_1.ModelRouter();
+    const model = router.pickFor("router");
+    const fallbackModel = router.fallbackFor("router");
+    try {
+        const result = await llm.structured({
+            model,
+            fallbackModel,
+            messages: [
+                { role: "system", content: buildTriageSystem() },
+                { role: "user", content: buildTriageUser(ctx) },
+            ],
+            schema: demoQuestion_schema_1.DemoTriageResultSchema,
+            schemaName: "DemoTriage",
+            temperature: 0.3,
+            maxTokens: 900,
+        });
+        const parsed = demoQuestion_schema_1.DemoTriageResultSchema.parse(result.data);
+        // Enforce our own guardrails regardless of what the model returned.
+        const questions = parsed.ask ? dedupeAndCap(parsed.questions) : [];
+        return {
+            ask: questions.length > 0,
+            ...(parsed.reason ? { reason: parsed.reason } : {}),
+            questions,
+            modelUsed: result.usedFallback && fallbackModel ? fallbackModel : model,
+            usage: result.usage,
+        };
+    }
+    catch {
+        return NO_QUESTIONS;
+    }
+}
+/** Drop duplicate ids and cap the set (defense-in-depth over the schema's max). */
+function dedupeAndCap(questions, cap = 3) {
+    const seen = new Set();
+    const out = [];
+    for (const q of questions) {
+        if (seen.has(q.id))
+            continue;
+        seen.add(q.id);
+        out.push(q);
+        if (out.length >= cap)
+            break;
+    }
+    return out;
+}

package/lib/services/demo/githubOAuth.d.ts

@@ -0,0 +1,78 @@
+/**
+ * GitHub OAuth App client — the v2 "connect GitHub for private repos" provider
+ * (plan §5, Phase 9). VidSpotAI is the OAuth CLIENT; GitHub is the provider. A
+ * classic OAuth App 3-legged flow: authorize → exchange code → non-expiring
+ * access token. We request `repo` (private-repo read) + `read:user` (identity).
+ *
+ * DORMANT until provisioned: everything gates on `GITHUB_OAUTH_CLIENT_ID` +
+ * `GITHUB_OAUTH_CLIENT_SECRET`. Until an app is registered and those land in
+ * Doppler, `isGithubOAuthConfigured()` is false and the connect endpoint 503s —
+ * exactly like the rest of the demo feature ships behind a flag.
+ *
+ * Env:
+ *   GITHUB_OAUTH_CLIENT_ID     — the OAuth App client id
+ *   GITHUB_OAUTH_CLIENT_SECRET — the OAuth App client secret
+ *   GITHUB_OAUTH_REDIRECT_URI  — must EXACTLY match the app's Authorization
+ *                                callback URL, e.g.
+ *                                https://<api-host>/v1/demo-video/github/callback
+ */
+/**
+ * Scopes we request. `repo` is the classic scope that grants private-repo
+ * access (GitHub OAuth Apps have no read-only private-repo scope — that
+ * granularity requires a GitHub App installation, a much larger integration);
+ * `read:user` is identity only. Documented as broad in the plan §10 risks.
+ */
+export declare const GITHUB_OAUTH_SCOPES: readonly ["read:user", "repo"];
+/** True once both client id + secret are configured. Gate the connect flow on this. */
+export declare function isGithubOAuthConfigured(): boolean;
+/** The registered callback URL. Must byte-match the OAuth App's setting. */
+export declare function githubRedirectUri(): string;
+/** Build the GitHub authorize URL the client opens to start consent. */
+export declare function buildGithubAuthUrl(state: string): string;
+export interface GithubTokenResult {
+    accessToken: string;
+    /** Scopes GitHub actually granted (may be a subset of requested). */
+    scopes: string[];
+}
+/**
+ * Exchange the authorization `code` for an access token. Throws on any
+ * error response (GitHub returns 200 with an `error` field on failure).
+ */
+export declare function exchangeGithubCode(code: string): Promise<GithubTokenResult>;
+export interface GithubUser {
+    id: number;
+    login: string;
+    avatarUrl?: string;
+}
+/** Fetch the authenticated user's identity for display. Throws on failure. */
+export declare function fetchGithubUser(accessToken: string): Promise<GithubUser>;
+export interface GithubRepoSummary {
+    /** "owner/name" — what we store as the repo URL basis. */
+    fullName: string;
+    name: string;
+    owner: string;
+    private: boolean;
+    description?: string;
+    /** Default branch (e.g. "main") — handy for the contents API later. */
+    defaultBranch: string;
+    htmlUrl: string;
+    /** ISO timestamp of last push, for "sort by recently active" in the picker. */
+    updatedAt?: string;
+}
+/**
+ * List the connected user's repositories for the repo picker (plan §9 UX).
+ * Mirrors `fetchGithubUser`'s auth headers against `GET /user/repos`. Pulls up
+ * to `maxPages` pages of 100, sorted by most-recently pushed, spanning repos the
+ * user owns / collaborates on / can see via org membership. Best-effort per page:
+ * a mid-pagination failure returns what we have rather than throwing.
+ */
+export declare function listGithubRepos(accessToken: string, opts?: {
+    maxPages?: number;
+}): Promise<GithubRepoSummary[]>;
+/**
+ * Best-effort provider-side revoke of a token grant (called on disconnect).
+ * Uses the OAuth App's client credentials via Basic auth. Non-fatal — returns
+ * false instead of throwing so a disconnect always completes locally.
+ */
+export declare function revokeGithubToken(accessToken: string): Promise<boolean>;
+//# sourceMappingURL=githubOAuth.d.ts.map

package/lib/services/demo/githubOAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"githubOAuth.d.ts","sourceRoot":"","sources":["../../../src/services/demo/githubOAuth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,gCAAiC,CAAC;AAIlE,uFAAuF;AACvF,wBAAgB,uBAAuB,IAAI,OAAO,CAKjD;AAcD,4EAA4E;AAC5E,wBAAgB,iBAAiB,IAAI,MAAM,CAI1C;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUxD;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAoC5B;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,8EAA8E;AAC9E,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAwB9E;AAED,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,EACnB,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA8C9B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAsB7E"}