autokap 1.6.1 → 1.6.3

package/dist/execution-schema.d.ts

@@ -1072,9 +1072,9 @@ export declare const PreconditionSpecSchema: z.ZodObject<{
             httpOnly: z.ZodBoolean;
             secure: z.ZodBoolean;
             sameSite: z.ZodEnum<{
-                Strict: "Strict";
                 Lax: "Lax";
                 None: "None";
+                Strict: "Strict";
             }>;
         }, z.core.$strict>>;
         origins: z.ZodArray<z.ZodObject<{
@@ -1221,9 +1221,9 @@ export declare const ExecutionProgramSchema: z.ZodObject<{
                 httpOnly: z.ZodBoolean;
                 secure: z.ZodBoolean;
                 sameSite: z.ZodEnum<{
-                    Strict: "Strict";
                     Lax: "Lax";
                     None: "None";
+                    Strict: "Strict";
                 }>;
             }, z.core.$strict>>;
             origins: z.ZodArray<z.ZodObject<{
@@ -2226,6 +2226,9 @@ export declare const ExecutionProgramSchema: z.ZodObject<{
         defaultValues: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
         replaceExisting: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>>;
+    deviceConfigs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    publicUrl: z.ZodOptional<z.ZodString>;
+    environmentHttpHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>;
 export declare const HealerPatchSchema: z.ZodObject<{
     opcodeIndex: z.ZodNumber;
@@ -4182,7 +4185,7 @@ export declare function safeParseProgramResult(data: unknown): z.ZodSafeParseRes
                 expires: number;
                 httpOnly: boolean;
                 secure: boolean;
-                sameSite: "Strict" | "Lax" | "None";
+                sameSite: "Lax" | "None" | "Strict";
             }[];
             origins: {
                 origin: string;
@@ -4923,4 +4926,7 @@ export declare function safeParseProgramResult(data: unknown): z.ZodSafeParseRes
         defaultValues: Record<string, string>[];
         replaceExisting?: boolean | undefined;
     }[] | undefined;
+    deviceConfigs?: Record<string, Record<string, unknown>> | undefined;
+    publicUrl?: string | undefined;
+    environmentHttpHeaders?: Record<string, string> | undefined;
 }>;

package/dist/execution-schema.js

@@ -652,6 +652,18 @@ export const ExecutionProgramSchema = z.object({
     compiledAt: z.string().datetime(),
     compiledWith: z.string().optional(),
     mockDataGroups: z.array(MockDataGroupSchema).optional(),
+    // Server-embedded device frame configs. Shape is governed by the
+    // `device_mockups.config` JSON column; we accept anything the server stores
+    // and let mockup.ts validate structurally at use time.
+    deviceConfigs: z.record(z.string().min(1), z.record(z.string(), z.unknown())).optional(),
+    // Project-level public URL used to rewrite the captured origin when
+    // decorating browser mockups. Validated only as a non-empty string here;
+    // the runtime parses it with `new URL()` and falls back gracefully.
+    publicUrl: z.string().min(1).optional(),
+    // Auth headers attached to the resolved project environment. Key/value
+    // pairs that Playwright will inject as `extraHTTPHeaders` on the
+    // BrowserContext so protected staging/preview URLs load successfully.
+    environmentHttpHeaders: z.record(z.string().min(1), z.string().min(1)).optional(),
 }).strict().superRefine((value, ctx) => {
     if (value.mediaMode !== value.artifactPlan.mediaMode) {
         ctx.addIssue({

package/dist/execution-types.d.ts

@@ -5,7 +5,8 @@
  * preset (natural language) -> ExecutionProgram (typed IR) -> deterministic runtime
  */
 import type { AKTree, BrowserStorageState, BrowserSessionStorageState, OutscaleConfig, VideoCursorTheme, VideoPageSignals } from './types.js';
-import type { MockupOptions } from './mockup.js';
+import type { DeviceConfig, MockupOptions } from './mockup.js';
+export type { DeviceConfig };
 /** Sentinel value that resolves to the current variant's locale or theme at runtime */
 export declare const VARIANT_PLACEHOLDER: "$variant";
 export declare const OPCODE_KINDS: readonly ["NAVIGATE", "DISMISS_OVERLAYS", "ASSERT_ROUTE", "ASSERT_SURFACE", "CLICK", "TYPE", "PRESS_KEY", "WAIT_FOR", "SLEEP", "SET_LOCALE", "SET_THEME", "SCROLL", "CAPTURE_SCREENSHOT", "BEGIN_CLIP", "END_CLIP", "HOVER", "SELECT_OPTION", "CHECK", "DOUBLE_CLICK", "DRAG", "CLONE_ELEMENT", "INJECT_MOCK_DATA", "REMOVE_ELEMENT", "SET_ATTRIBUTE"];
@@ -557,6 +558,28 @@ export interface ExecutionProgram {
      * Compiled from PresetConfig.mockDataInjection.groups by the server.
      */
     mockDataGroups?: MockDataGroup[];
+    /**
+     * Server-embedded device frame configs for every `deviceFrame` referenced by
+     * `variants[]`. The CLI seeds its mockup engine with these so it does not
+     * need direct Supabase access (end-users do not have the service role key).
+     * Keyed by the exact deviceFrame string used in the variants.
+     */
+    deviceConfigs?: Record<string, DeviceConfig>;
+    /**
+     * Project-level public URL used to decorate browser mockups. The CLI
+     * substitutes the captured origin (typically a local dev server) with this
+     * value via `transformBrowserUrl` before baking it into the browser bar.
+     * Server-resolved from `projects.public_url`.
+     */
+    publicUrl?: string;
+    /**
+     * Auth headers attached to the resolved project environment (Bearer token,
+     * Vercel protection bypass, x-api-key, etc.). Injected into the Playwright
+     * BrowserContext so requests to protected staging/preview URLs go through.
+     * Decrypted server-side from `project_environments.auth_headers_encrypted`
+     * and embedded in the signed program envelope.
+     */
+    environmentHttpHeaders?: Record<string, string>;
 }
 export interface CircuitBreakerConfig {
     /** Max recovery attempts per opcode. Default: 3 */
@@ -629,6 +652,8 @@ export interface ArtifactResult {
     altText?: string;
     /** Final URL at the time the artifact was produced */
     captureUrl?: string;
+    /** Document title at the time the artifact was produced (page.title()) */
+    pageTitle?: string;
     /** Step index that produced the artifact */
     stepIndex?: number;
     /** Human-readable label for the artifact */
@@ -855,6 +880,13 @@ export interface RuntimeAdapter {
         buffer: Buffer;
         mimeType: string;
     } | null>;
+    /**
+     * Document title of the current page (Playwright's `page.title()`). Captured
+     * at screenshot time and stored on the artifact metadata so browser mockups
+     * can render the actual page title instead of just the hostname. Optional —
+     * adapters that cannot resolve a title should leave this method off.
+     */
+    getPageTitle?(): Promise<string | null>;
     /**
      * Read the captured app's version from the live page (meta tag, window
      * global, or data attribute). Mirrors `extractAppVersionFromHtml` server-side
@@ -958,4 +990,3 @@ export interface RuntimeAdapter {
         selector: string;
     }): Promise<void>;
 }
-export {};

package/dist/mockup.d.ts

@@ -11,7 +11,8 @@ export interface DeviceFrameDefinition {
         height: number;
     };
 }
-interface OrientationConfigData {
+export type DeviceOrientation = 'portrait' | 'landscape';
+export interface OrientationConfigData {
     screen: {
         logicalWidth: number;
         logicalHeight: number;
@@ -103,6 +104,69 @@ interface OrientationConfigData {
         right?: string;
     };
 }
+export interface DeviceConfig {
+    id: string;
+    name: string;
+    category: DeviceCategory;
+    platform: string;
+    frameOrientation?: 'portrait' | 'landscape';
+    supportedOrientations?: ('portrait' | 'landscape')[];
+    orientations?: {
+        portrait?: OrientationConfigData;
+        landscape?: OrientationConfigData;
+    };
+    /** Row-level frame_url (shared fallback for all orientations) */
+    _rowFrameUrl?: string;
+    screen: {
+        logicalWidth: number;
+        logicalHeight: number;
+        scale: number;
+        cornerRadius: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    safeArea?: {
+        top: number;
+        bottom: number;
+        left?: number;
+        right?: number;
+    };
+    statusBar?: {
+        asset: string;
+        height: number;
+        width: number;
+        type?: StatusBarDeviceType;
+        layout?: StatusBarLayout;
+    };
+    homeIndicator?: {
+        width: number;
+        height: number;
+        cornerRadius: number;
+        bottomOffset: number;
+    };
+    frame: {
+        type: 'png' | 'svg';
+        asset: string;
+        width: number;
+        height: number;
+        screenRect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    frameRotation?: number;
+    frameBehindContent?: boolean;
+    windowBorder?: OrientationConfigData['windowBorder'];
+    frameDarkUrl?: string;
+    browserBarZones?: OrientationConfigData['browserBarZones'];
+    browserStyle?: OrientationConfigData['browserStyle'];
+    adminShowStatusBar?: OrientationConfigData['adminShowStatusBar'];
+    adminForcedSafeAreaColors?: OrientationConfigData['adminForcedSafeAreaColors'];
+}
 export type MockupOrientation = 'portrait' | 'landscape';
 export interface MockupOptions {
     orientation?: MockupOrientation;
@@ -184,6 +248,7 @@ export interface ResolvedDeviceFrameDescriptor {
     disableOverlays: boolean;
 }
 export declare function invalidateDeviceConfigCache(): void;
+export declare function seedDeviceConfigs(configs: Record<string, DeviceConfig> | null | undefined): void;
 export declare function resolveDeviceFrameDescriptor(id: DeviceFrameId, options?: {
     orientation?: MockupOrientation;
 }): Promise<ResolvedDeviceFrameDescriptor | null>;
@@ -191,4 +256,3 @@ export declare function rasterizeDeviceFrame(descriptor: ResolvedDeviceFrameDesc
 export declare function getDeviceFrames(): Promise<DeviceFrameDefinition[]>;
 export declare function getDeviceFrame(id: DeviceFrameId): Promise<DeviceFrameDefinition | undefined>;
 export declare function applyDeviceFrame(screenshot: Buffer, deviceId: DeviceFrameId, options?: MockupOptions): Promise<Buffer>;
-export {};

package/dist/mockup.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import { renderStatusBarBuffer } from './status-bar-render.js';
 import { generateBrowserBarSvg } from './browser-bar.js';
 import { computeMockupLayout } from './mockup-html.js';
+import { logger } from './logger.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const DEVICES_DIR = path.join(__dirname, '..', 'assets', 'devices');
@@ -144,7 +145,23 @@ function resolveOrientationConfig(config, requestedOrientation) {
         adminForcedSafeAreaColors: config.adminForcedSafeAreaColors,
     };
 }
+// Server-provided device configs embedded in signed execution programs. When
+// set, these short-circuit `loadDeviceConfigs` — the CLI does not need direct
+// Supabase access (and end-users do not have the service role key) because the
+// server already vetted every device referenced by the program's variants and
+// inlined the rows.
+let seededDeviceConfigs = null;
+export function seedDeviceConfigs(configs) {
+    if (!configs || Object.keys(configs).length === 0) {
+        seededDeviceConfigs = null;
+        return;
+    }
+    seededDeviceConfigs = new Map(Object.entries(configs));
+}
 async function loadDeviceConfigs() {
+    if (seededDeviceConfigs && seededDeviceConfigs.size > 0) {
+        return seededDeviceConfigs;
+    }
     if (configCache && configCache.expiresAt > Date.now()) {
         return configCache.configs;
     }
@@ -478,12 +495,12 @@ export async function applyDeviceFrame(screenshot, deviceId, options) {
     const isBrowserDevice = config.category === 'browser';
     const os = Math.max(0.5, Math.min(4, opts.outputScale));
     const geometry = computeResolvedFrameGeometry(resolved);
-    console.log(`[mockup] applyDeviceFrame: id=${deviceId}, category=${config.category}, orientation=${requestedOrientation}`);
-    console.log(`[mockup]   hasOrientationConfig=${!!config.orientations?.[requestedOrientation]}, orientations=${JSON.stringify(Object.keys(config.orientations ?? {}))}`);
-    console.log(`[mockup]   resolved.screen:`, JSON.stringify(resolved.screen));
-    console.log(`[mockup]   resolved.frame: w=${resolved.frame.width} h=${resolved.frame.height} asset="${resolved.frame.asset}" url=${resolved.frameUrl ? 'yes' : 'no'}`);
-    console.log(`[mockup]   resolved.safeArea:`, JSON.stringify(resolved.safeArea));
-    console.log(`[mockup]   scale=${scale}, outputScale=${os}`);
+    logger.debug(`[mockup] applyDeviceFrame: id=${deviceId}, category=${config.category}, orientation=${requestedOrientation}`);
+    logger.debug(`[mockup]   hasOrientationConfig=${!!config.orientations?.[requestedOrientation]}, orientations=${JSON.stringify(Object.keys(config.orientations ?? {}))}`);
+    logger.debug(`[mockup]   resolved.screen: ${JSON.stringify(resolved.screen)}`);
+    logger.debug(`[mockup]   resolved.frame: w=${resolved.frame.width} h=${resolved.frame.height} asset="${resolved.frame.asset}" url=${resolved.frameUrl ? 'yes' : 'no'}`);
+    logger.debug(`[mockup]   resolved.safeArea: ${JSON.stringify(resolved.safeArea)}`);
+    logger.debug(`[mockup]   scale=${scale}, outputScale=${os}`);
     // Browser devices can work without a frame image
     const hasFrame = !!(resolved.frameUrl || resolved.frame.asset);
     let frameData = null;
@@ -509,7 +526,7 @@ export async function applyDeviceFrame(screenshot, deviceId, options) {
         geo.frameWidth = logicalW;
         geo.frameHeight = logicalH;
         geo.screenRect = { x: 0, y: 0, width: logicalW, height: logicalH };
-        console.log(`[mockup]   frameless browser: logicalW=${logicalW}, logicalH=${logicalH}, os=${os}, geo=${geo.frameWidth}x${geo.frameHeight}`);
+        logger.debug(`[mockup]   frameless browser: logicalW=${logicalW}, logicalH=${logicalH}, os=${os}, geo=${geo.frameWidth}x${geo.frameHeight}`);
     }
     else if (!hasFrame && geo.frameWidth === 0 && geo.frameHeight === 0) {
         // Non-browser frameless fallback
@@ -551,21 +568,21 @@ export async function applyDeviceFrame(screenshot, deviceId, options) {
     });
     const contentW = layout.contentArea.width;
     const contentH = layout.contentArea.height;
-    console.log(`[mockup]   hasFrame=${hasFrame}, geo: fw=${geo.frameWidth} fh=${geo.frameHeight} sr=${JSON.stringify(geo.screenRect)}`);
-    console.log(`[mockup]   layout: container=${layout.containerWidth}x${layout.containerHeight} content=${contentW}x${contentH} contentArea=${JSON.stringify(layout.contentArea)}`);
+    logger.debug(`[mockup]   hasFrame=${hasFrame}, geo: fw=${geo.frameWidth} fh=${geo.frameHeight} sr=${JSON.stringify(geo.screenRect)}`);
+    logger.debug(`[mockup]   layout: container=${layout.containerWidth}x${layout.containerHeight} content=${contentW}x${contentH} contentArea=${JSON.stringify(layout.contentArea)}`);
     // Get incoming screenshot dimensions for logging
     const screenshotMeta = await sharp(screenshot).metadata();
-    console.log(`[mockup]   input screenshot: ${screenshotMeta.width}x${screenshotMeta.height}`);
+    logger.debug(`[mockup]   input screenshot: ${screenshotMeta.width}x${screenshotMeta.height}`);
     const physicalContentW = Math.round(contentW * os);
     const physicalContentH = Math.round(contentH * os);
-    console.log(`[mockup]   resize target: ${physicalContentW}x${physicalContentH}`);
+    logger.debug(`[mockup]   resize target: ${physicalContentW}x${physicalContentH}`);
     if (screenshotMeta.width
         && screenshotMeta.height
         && (Math.abs(screenshotMeta.width - physicalContentW) > 1
             || Math.abs(screenshotMeta.height - physicalContentH) > 1)) {
         const ratioX = physicalContentW / screenshotMeta.width;
         const ratioY = physicalContentH / screenshotMeta.height;
-        console.warn(`[mockup]   screenshot will be resampled: ` +
+        logger.debug(`[mockup]   screenshot will be resampled: ` +
             `${screenshotMeta.width}x${screenshotMeta.height} -> ` +
             `${physicalContentW}x${physicalContentH} ` +
             `(x=${ratioX.toFixed(4)}, y=${ratioY.toFixed(4)}). ` +
@@ -597,7 +614,7 @@ export async function applyDeviceFrame(screenshot, deviceId, options) {
         colors.leftColor = sanitizeCssColor(opts.safeAreaLeftColor);
     if (opts.safeAreaRightColor)
         colors.rightColor = sanitizeCssColor(opts.safeAreaRightColor);
-    console.log(`[mockup]   sampled colors: top=${colors.topColor} bottom=${colors.bottomColor} left=${colors.leftColor} right=${colors.rightColor}`);
+    logger.debug(`[mockup]   sampled colors: top=${colors.topColor} bottom=${colors.bottomColor} left=${colors.leftColor} right=${colors.rightColor}`);
     // Determine color scheme: use explicit override if provided, otherwise auto-detect from edge colors.
     // Laptops (MacBook) always use dark menu bar (white text on black background).
     const isLaptop = config.category === 'laptop';
@@ -664,7 +681,7 @@ export async function applyDeviceFrame(screenshot, deviceId, options) {
     const renderW = Math.round(geo.frameWidth);
     const renderH = Math.round(geo.frameHeight);
     const cornerRadius = (resolved.screen?.cornerRadius ?? 0) * scale;
-    console.log(`[mockup]   composeMockup: ${renderW}x${renderH} @${os}x, showBrowserBar=${isBrowserDevice}, windowBorderWidth=${wbw}`);
+    logger.debug(`[mockup]   composeMockup: ${renderW}x${renderH} @${os}x, showBrowserBar=${isBrowserDevice}, windowBorderWidth=${wbw}`);
     // ── Sharp compositing — layer-by-layer mockup assembly ──
     // All dimensions in physical pixels (logical * os).
     const pw = Math.round(renderW * os);

package/dist/opcode-runner.js

@@ -708,12 +708,21 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
                         tabIconMimeType = favicon.mimeType;
                     }
                 }
+                // Capture document title so browser mockups can render the real tab
+                // title instead of falling back to the hostname.
+                let pageTitle;
+                if (adapter.getPageTitle) {
+                    const resolved = await adapter.getPageTitle();
+                    if (resolved)
+                        pageTitle = resolved;
+                }
                 artifacts.push({
                     mediaMode: 'screenshot',
                     buffer,
                     mimeType: 'image/png',
                     captureType: opcode.elementSelector ? 'element' : 'fullpage',
                     captureUrl,
+                    pageTitle,
                     dimensions: currentVariant?.viewport,
                     captureId: opcode.captureId,
                     captureName: opcode.captureName ?? opcode.description,

package/dist/program-signing.d.ts

@@ -121,9 +121,9 @@ export declare const SignedExecutionProgramEnvelopeSchema: z.ZodObject<{
                     httpOnly: z.ZodBoolean;
                     secure: z.ZodBoolean;
                     sameSite: z.ZodEnum<{
-                        Strict: "Strict";
                         Lax: "Lax";
                         None: "None";
+                        Strict: "Strict";
                     }>;
                 }, z.core.$strict>>;
                 origins: z.ZodArray<z.ZodObject<{
@@ -1126,6 +1126,9 @@ export declare const SignedExecutionProgramEnvelopeSchema: z.ZodObject<{
             defaultValues: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
             replaceExisting: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>>;
+        deviceConfigs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        publicUrl: z.ZodOptional<z.ZodString>;
+        environmentHttpHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strict>;
     signature: z.ZodString;
     meta: z.ZodOptional<z.ZodObject<{

package/dist/program-signing.js

@@ -102,6 +102,10 @@ export function signExecutionProgramEnvelope(params) {
     };
 }
 export function verifySignedExecutionProgramEnvelope(params) {
+    // The Zod schema describes `deviceConfigs` as a loose record (the server is
+    // the source of truth for the rich DeviceConfig shape). Cast to the strongly
+    // typed envelope at this trust boundary — the signature verification below
+    // proves the server produced this payload.
     const envelope = SignedExecutionProgramEnvelopeSchema.parse(params.envelope);
     const payload = {
         signedAt: envelope.signedAt,

package/dist/skill-packaging.d.ts

@@ -1,28 +1,12 @@
 export type SkillType = 'preset';
-export type SkillAgent = 'claude' | 'codex' | 'cursor' | 'windsurf' | 'copilot';
 export interface SkillPlaceholderOptions {
     projectUrl?: string;
     projectId?: string;
     apiBaseUrl?: string;
 }
-export interface SkillExportResult {
-    mode: 'single-file' | 'bundle';
-    writtenPaths: string[];
-}
 export declare function resolveSkillAssetDir(): Promise<string>;
-export declare function shouldInstallSkillBundle(params: {
-    agent?: string;
-    outputPath?: string;
-    type: SkillType;
-}): boolean;
 export declare function renderSkillSingleFile(params: {
     type: SkillType;
     agent?: string;
     placeholders: SkillPlaceholderOptions;
 }): Promise<string>;
-export declare function writeSkillExport(params: {
-    type: SkillType;
-    agent?: string;
-    outputPath: string;
-    placeholders: SkillPlaceholderOptions;
-}): Promise<SkillExportResult>;

package/dist/skill-packaging.js

@@ -17,6 +17,7 @@ const PRESET_SKILL_SOURCE = {
     coreFile: 'SKILL.md',
     references: [
         { relativePath: 'OPCODE-REFERENCE.md', title: 'Opcode Reference', anchor: 'reference-opcode-reference' },
+        { relativePath: 'references/STANDARDS.md', title: 'Prompt Charter & Quality Standards', anchor: 'reference-prompt-standards' },
         { relativePath: 'references/mock-data.md', title: 'Mock Data Injection', anchor: 'reference-mock-data-injection' },
         { relativePath: 'references/examples.md', title: 'Complete Examples', anchor: 'reference-complete-examples' },
     ],
@@ -57,23 +58,6 @@ export async function resolveSkillAssetDir() {
     }
     throw new Error('Could not find assets/skill. Make sure the autokap package is installed correctly.');
 }
-function inferBundleInstall(outputPath) {
-    if (!outputPath)
-        return false;
-    const normalized = path.normalize(outputPath);
-    const parts = normalized.split(path.sep).filter(Boolean);
-    for (let index = 0; index < parts.length - 1; index += 1) {
-        if (parts[index] === '.agents' && parts[index + 1] === 'skills') {
-            return path.basename(normalized) === 'SKILL.md';
-        }
-    }
-    return false;
-}
-export function shouldInstallSkillBundle(params) {
-    if (params.agent?.toLowerCase() === 'codex')
-        return true;
-    return inferBundleInstall(params.outputPath);
-}
 async function readSkillFile(rootDir, relativePath, placeholders) {
     const absolutePath = path.join(rootDir, relativePath);
     const raw = await fs.readFile(absolutePath, 'utf-8');
@@ -122,38 +106,4 @@ export async function renderSkillSingleFile(params) {
     }
     return [core, ...bundledReferences].join('\n\n');
 }
-export async function writeSkillExport(params) {
-    const rootDir = await resolveSkillAssetDir();
-    const spec = getSkillSourceSpec(params.type);
-    if (shouldInstallSkillBundle({
-        agent: params.agent,
-        outputPath: params.outputPath,
-        type: params.type,
-    })) {
-        const destinationDir = path.dirname(params.outputPath);
-        const writtenPaths = [];
-        for (const relativePath of [spec.coreFile, ...spec.references.map((reference) => reference.relativePath)]) {
-            const absolutePath = path.join(destinationDir, relativePath);
-            const content = await readSkillFile(rootDir, relativePath, params.placeholders);
-            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-            await fs.writeFile(absolutePath, content, 'utf-8');
-            writtenPaths.push(absolutePath);
-        }
-        return {
-            mode: 'bundle',
-            writtenPaths,
-        };
-    }
-    const content = await renderSkillSingleFile({
-        type: params.type,
-        agent: params.agent,
-        placeholders: params.placeholders,
-    });
-    await fs.mkdir(path.dirname(params.outputPath), { recursive: true });
-    await fs.writeFile(params.outputPath, content, 'utf-8');
-    return {
-        mode: 'single-file',
-        writtenPaths: [params.outputPath],
-    };
-}
 //# sourceMappingURL=skill-packaging.js.map

package/dist/transform-browser-url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transform a captured URL for display in the browser bar mockup.
+ * 1. Replace the origin with `publicUrl` (if provided).
+ * 2. Strip UUID v4 path segments.
+ */
+export declare function transformBrowserUrl(capturedUrl: string, publicUrl?: string | null): string;

package/dist/transform-browser-url.js

@@ -0,0 +1,28 @@
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Transform a captured URL for display in the browser bar mockup.
+ * 1. Replace the origin with `publicUrl` (if provided).
+ * 2. Strip UUID v4 path segments.
+ */
+export function transformBrowserUrl(capturedUrl, publicUrl) {
+    let parsed;
+    try {
+        parsed = new URL(capturedUrl);
+    }
+    catch {
+        return capturedUrl;
+    }
+    if (publicUrl) {
+        try {
+            const pub = new URL(publicUrl);
+            parsed = new URL(`${pub.origin}${parsed.pathname}${parsed.search}${parsed.hash}`);
+        }
+        catch {
+            // invalid publicUrl — skip origin replacement
+        }
+    }
+    const segments = parsed.pathname.split("/").filter((s) => s && !UUID_RE.test(s));
+    parsed.pathname = "/" + segments.join("/");
+    return parsed.toString().replace(/\/$/, "") || parsed.origin;
+}
+//# sourceMappingURL=transform-browser-url.js.map

package/dist/types.d.ts

@@ -246,6 +246,17 @@ export interface BrowserOptions {
     colorScheme?: 'light' | 'dark';
     /** Optional persisted cookies/localStorage captured during preparation. */
     storageState?: BrowserStorageState;
+    /**
+     * Extra HTTP headers injected on every navigation. Used to carry the
+     * environment-level auth (Bearer token, Vercel protection bypass, x-api-key,
+     * etc.) configured on the resolved `project_environments` row.
+     *
+     * These headers are sent to ALL requests the BrowserContext makes during
+     * capture, including cross-origin requests (third-party CDN, analytics).
+     * The dashboard surfaces a warning so users only put environment-scoped
+     * secrets here.
+     */
+    extraHttpHeaders?: Record<string, string>;
 }
 export interface OutscaleConfig {
     /** Uniform padding on all 4 sides (pixels). */

package/dist/video-narration-schema.d.ts

@@ -147,9 +147,9 @@ export declare const VideoIngestPayloadSchema: z.ZodObject<{
                     httpOnly: z.ZodBoolean;
                     secure: z.ZodBoolean;
                     sameSite: z.ZodEnum<{
-                        Strict: "Strict";
                         Lax: "Lax";
                         None: "None";
+                        Strict: "Strict";
                     }>;
                 }, z.core.$strict>>;
                 origins: z.ZodArray<z.ZodObject<{
@@ -1152,6 +1152,9 @@ export declare const VideoIngestPayloadSchema: z.ZodObject<{
             defaultValues: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
             replaceExisting: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>>;
+        deviceConfigs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        publicUrl: z.ZodOptional<z.ZodString>;
+        environmentHttpHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strict>;
     narration: z.ZodOptional<z.ZodObject<{
         voice: z.ZodString;

package/dist/web-playwright-local.d.ts

@@ -27,6 +27,7 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
     constructor(browser: Browser, recordingDir?: string | undefined);
     navigate(url: string): Promise<void>;
     getCurrentUrl(): Promise<string>;
+    getPageTitle(): Promise<string | null>;
     detectAppVersion(): Promise<string | null>;
     getAKTree(): Promise<AKTree>;
     getPageSignals(): Promise<VideoPageSignals>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",
@@ -181,14 +181,15 @@
     "./program-signing": {
       "types": "./dist/program-signing.d.ts",
       "default": "./dist/program-signing.js"
+    },
+    "./transform-browser-url": {
+      "types": "./dist/transform-browser-url.d.ts",
+      "default": "./dist/transform-browser-url.js"
     }
   },
   "bin": {
     "autokap": "dist/cli.js"
   },
-  "scripts": {
-    "postinstall": "node -e \"try{require('child_process').execSync('npx playwright install chromium',{stdio:'inherit'})}catch(e){console.warn('AutoKap: Playwright Chromium install failed. Run npx playwright install chromium manually.',e.message||'')}\""
-  },
   "engines": {
     "node": ">=20"
   },
@@ -203,8 +204,7 @@
     "assets/frames/MacBook*",
     "assets/frames/Status*",
     "assets/icons",
-    "assets/cursors",
-    "assets/skill"
+    "assets/cursors"
   ],
   "keywords": [
     "screenshot",

package/readme.md

@@ -1,20 +1,23 @@
-# AutoKap
+# AutoKap (backend package)
 
-AI-powered website screenshot capture across every device, language, and theme.
+AI-powered website screenshot capture across every device, language, and
+theme.
 
-## Quick Start
+This npm package (`autokap`) is the **backend** consumed by:
 
-```bash
-# Install dependencies
-cd web && npm install
+- the AutoKap Cloud Run service that handles
+  `npx autokap auto-recapture --cloud` jobs, and
+- the official MCP server `@autokap/mcp`, which spawns the package as a
+  sub-process for local capture execution (`autokap_start_capture`).
 
-# Set up environment
-cp .env.example .env.local
-# Fill in NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY
+**You probably do not need to install this package directly.** Wire your
+IDE assistant to `@autokap/mcp` instead — see the per-IDE install guides
+in the repository root README and the
+[migration guide](https://github.com/autokap/autokap/blob/main/MIGRATION-v1-to-v2.md).
 
-# Run dev server
-npm run dev
-```
+The advanced commands `autokap login`, `autokap run`, `autokap doctor`,
+and `autokap auto-recapture` remain available for users who need a
+scriptable backend (CI/CD, custom orchestrators).
 
 ## Recapture Cloud in CI/CD