@playdrop/playdrop-cli 0.4.1 → 0.5.0

package/README.md

@@ -32,10 +32,10 @@ playdrop project publish .
 ## Links
 
 - Website: [playdrop.ai](https://www.playdrop.ai/)
-- Getting started: [playdrop.ai/docs/getting-started](https://www.playdrop.ai/docs/getting-started)
+- Getting started: [playdrop.ai/getting-started](https://www.playdrop.ai/getting-started)
 - CLI docs: [playdrop.ai/docs/cli](https://www.playdrop.ai/docs/cli)
-- SDK docs: [playdrop.ai/docs/sdk](https://www.playdrop.ai/docs/sdk)
-- Templates and demos: [playdrop.ai/docs/samples/templates-and-demos](https://www.playdrop.ai/docs/samples/templates-and-demos)
+- Runtime docs: [playdrop.ai/docs/runtime](https://www.playdrop.ai/docs/runtime)
+- Templates and demos: [playdrop.ai/docs/examples#templates-and-demos](https://www.playdrop.ai/docs/examples#templates-and-demos)
 - Public Playdrop skill: [skills.sh/playdrop-ai/playdrop-skills/playdrop](https://skills.sh/playdrop-ai/playdrop-skills/playdrop)
 
 ## Live Examples
@@ -100,5 +100,5 @@ playdrop project publish .
 
 ```bash
 playdrop documentation browse
-playdrop documentation read getting-started.md
+playdrop documentation read runtime
 ```

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.4.1",
-  "build": 3,
+  "version": "0.5.0",
+  "build": 2,
   "platforms": {
     "ios": {
       "minimumVersion": "16.0"
@@ -26,19 +26,19 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.4.1",
-      "minimumBuild": 3
+      "minimumVersion": "0.5.0",
+      "minimumBuild": 2
     },
     "admin": {
-      "minimumVersion": "0.4.1",
-      "minimumBuild": 3
+      "minimumVersion": "0.5.0",
+      "minimumBuild": 2
     },
     "apple": {
       "minimumVersion": "0.3.10",
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.4.1"
+      "minimumVersion": "0.5.0"
     }
   }
 }

package/dist/apps/upload.js

@@ -58,12 +58,38 @@ async function uploadAppVersion(client, task, artifacts, options) {
         remixRef: task.remix,
         surfaceTargets: task.surfaceTargets,
         entryPoint: artifacts?.metadata?.entryPoint ?? undefined,
+        authMode: task.authMode,
+        controllerMode: task.controllerMode,
+        previewable: task.previewable,
         // App metadata (used when creating app if it doesn't exist)
         displayName: task.displayName,
         description: task.description,
         type: task.type,
         emoji: task.emoji ?? undefined,
         color: task.color ?? undefined,
+        achievements: task.achievements.map((definition) => ({
+            key: definition.key,
+            displayName: definition.displayName,
+            description: definition.description,
+            kind: definition.kind,
+            ...(definition.hidden ? { hidden: true } : {}),
+            ...(definition.maxProgress !== undefined ? { maxProgress: definition.maxProgress } : {}),
+            icon: definition.icon,
+            status: definition.status,
+        })),
+        leaderboards: task.leaderboards.map((definition) => ({
+            key: definition.key,
+            displayName: definition.displayName,
+            description: definition.description,
+            scoreType: definition.scoreType,
+            sort: definition.sort,
+            ...(definition.unitLabel ? { unitLabel: definition.unitLabel } : {}),
+            status: definition.status,
+        })),
+        achievementIconFiles: task.achievements.map((definition) => ({
+            key: definition.key,
+            file: createFileFromPath(definition.iconPath, 'image/png', isPngSignature),
+        })),
     };
     // For EXTERNAL hosting mode, use externalUrl instead of bundle
     if (task.hostingMode === 'EXTERNAL') {

package/dist/captureRuntime.js

@@ -7,7 +7,7 @@ exports.runCapture = runCapture;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const playwright_1 = require("./playwright");
-const ACCESS_TOKEN_COOKIE_NAME = 'playdrop_access_token';
+const sessionCookie_1 = require("./sessionCookie");
 const FRAME_SELECTOR = 'iframe[title="Game"]';
 const LOGIN_BUTTON_NAME = 'Sign in to play';
 exports.CAPTURE_LOG_LEVEL_VALUES = ['debug', 'info', 'warn', 'error'];
@@ -142,14 +142,7 @@ async function runCapture(options) {
         await (0, playwright_1.withChromiumPage)(async ({ context, page }) => {
             const targetOrigin = new URL(options.targetUrl).origin;
             if (bootstrapToken) {
-                await context.addCookies([
-                    {
-                        name: ACCESS_TOKEN_COOKIE_NAME,
-                        value: bootstrapToken,
-                        url: targetOrigin,
-                        path: '/',
-                    },
-                ]);
+                await context.addCookies((0, sessionCookie_1.buildCaptureAccessTokenCookies)(options.targetUrl, bootstrapToken));
             }
             if (bootstrapToken || bootstrapUser) {
                 await page.addInitScript(({ token, user }) => {

package/dist/catalogue.d.ts

@@ -1,4 +1,4 @@
-import { type AppSurface, type AppType, type AppHostingMode, type AppVersionVisibility } from '@playdrop/types';
+import { type AppSurface, type AppType, type AppHostingMode, type AppAuthMode, type AppControllerMode, type AppVersionVisibility, type AppAchievementCatalogueDefinition, type AppLeaderboardCatalogueDefinition, type PlayerMetaDefinitionStatus } from '@playdrop/types';
 export type CatalogueJson = {
     apps?: Array<Record<string, unknown>>;
     assets?: Array<Record<string, unknown>>;
@@ -17,6 +17,13 @@ export type AppListingConfig = {
     videosPortrait?: string[];
     videosLandscape?: string[];
 };
+export type ResolvedAppAchievementDefinition = Omit<AppAchievementCatalogueDefinition, 'status'> & {
+    iconPath: string;
+    status: PlayerMetaDefinitionStatus;
+};
+export type ResolvedAppLeaderboardDefinition = Omit<AppLeaderboardCatalogueDefinition, 'status'> & {
+    status: PlayerMetaDefinitionStatus;
+};
 export type AppCatalogueEntry = {
     name: string;
     displayName?: string;
@@ -35,9 +42,14 @@ export type AppCatalogueEntry = {
     releaseNotes?: string;
     visibility?: string;
     hostingMode?: string;
+    authMode?: string;
+    controllerMode?: string;
+    previewable?: boolean;
     externalUrl?: string;
     listing?: AppListingConfig;
     username?: string;
+    achievements?: AppAchievementCatalogueDefinition[];
+    leaderboards?: AppLeaderboardCatalogueDefinition[];
     embeddedAssets?: EmbeddedAssetCatalogueEntry[];
     uses?: {
         assets?: string[];
@@ -136,9 +148,14 @@ export type AppTask = {
     releaseNotes?: string;
     versionVisibility?: AppVersionVisibility;
     hostingMode?: AppHostingMode;
+    authMode?: AppAuthMode;
+    controllerMode?: AppControllerMode;
+    previewable?: boolean;
     externalUrl?: string;
     listing?: ResolvedListingAssets;
     username?: string;
+    achievements: ResolvedAppAchievementDefinition[];
+    leaderboards: ResolvedAppLeaderboardDefinition[];
     remix?: string;
     embeddedAssets: EmbeddedAssetTask[];
     uses: {

package/dist/catalogue.js

@@ -442,6 +442,163 @@ function validateOptionalColor(value, hasColorField, errors) {
     }
     return color;
 }
+function validateAchievementDefinitions(value, catalogueDir, errors) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        errors.push('achievements must be an array');
+        return [];
+    }
+    const seenKeys = new Set();
+    const definitions = [];
+    value.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            errors.push(`achievements[${index}] must be an object`);
+            return;
+        }
+        const key = typeof entry.key === 'string' ? entry.key.trim() : '';
+        if (!(0, types_1.isPlayerMetaKey)(key)) {
+            errors.push(`achievements[${index}].key must match the player meta key format`);
+            return;
+        }
+        if (seenKeys.has(key)) {
+            errors.push(`achievements contains duplicate key "${key}"`);
+            return;
+        }
+        seenKeys.add(key);
+        const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
+        if (!displayName) {
+            errors.push(`achievements[${index}].displayName must be a non-empty string`);
+            return;
+        }
+        const description = typeof entry.description === 'string' ? entry.description.trim() : '';
+        if (!description) {
+            errors.push(`achievements[${index}].description must be a non-empty string`);
+            return;
+        }
+        const kind = (0, types_1.parseAppAchievementKind)(entry.kind);
+        if (!kind) {
+            errors.push(`achievements[${index}].kind must be one of ${types_1.APP_ACHIEVEMENT_KIND_VALUES.join(', ')}`);
+            return;
+        }
+        const hidden = Boolean(entry.hidden);
+        const status = (0, types_1.parsePlayerMetaDefinitionStatus)(entry.status ?? 'ACTIVE');
+        if (!status) {
+            errors.push(`achievements[${index}].status must be one of ${types_1.PLAYER_META_DEFINITION_STATUS_VALUES.join(', ')}`);
+            return;
+        }
+        const icon = typeof entry.icon === 'string' ? entry.icon.trim() : '';
+        if (!icon) {
+            errors.push(`achievements[${index}].icon must be a non-empty PNG path`);
+            return;
+        }
+        const iconExtensionError = validateListingAssetExtension(icon, `achievements[${index}].icon`, 'image');
+        if (iconExtensionError) {
+            errors.push(iconExtensionError);
+            return;
+        }
+        const iconPathError = validateListingAssetPath(catalogueDir, icon, `achievements[${index}].icon`);
+        if (iconPathError) {
+            errors.push(iconPathError);
+            return;
+        }
+        const iconPath = resolveListingAssetPath(catalogueDir, icon);
+        let maxProgress;
+        if (kind === 'INCREMENTAL') {
+            if (!Number.isSafeInteger(entry.maxProgress) || Number(entry.maxProgress) <= 0) {
+                errors.push(`achievements[${index}].maxProgress must be a positive safe integer`);
+                return;
+            }
+            maxProgress = Number(entry.maxProgress);
+        }
+        else if (entry.maxProgress !== undefined) {
+            errors.push(`achievements[${index}].maxProgress is only valid for INCREMENTAL achievements`);
+            return;
+        }
+        definitions.push({
+            key,
+            displayName,
+            description,
+            kind,
+            hidden,
+            ...(maxProgress !== undefined ? { maxProgress } : {}),
+            icon,
+            iconPath,
+            status,
+        });
+    });
+    return definitions;
+}
+function validateLeaderboardDefinitions(value, errors) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        errors.push('leaderboards must be an array');
+        return [];
+    }
+    const seenKeys = new Set();
+    const definitions = [];
+    value.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            errors.push(`leaderboards[${index}] must be an object`);
+            return;
+        }
+        const key = typeof entry.key === 'string' ? entry.key.trim() : '';
+        if (!(0, types_1.isPlayerMetaKey)(key)) {
+            errors.push(`leaderboards[${index}].key must match the player meta key format`);
+            return;
+        }
+        if (seenKeys.has(key)) {
+            errors.push(`leaderboards contains duplicate key "${key}"`);
+            return;
+        }
+        seenKeys.add(key);
+        const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
+        if (!displayName) {
+            errors.push(`leaderboards[${index}].displayName must be a non-empty string`);
+            return;
+        }
+        const description = typeof entry.description === 'string' ? entry.description.trim() : '';
+        if (!description) {
+            errors.push(`leaderboards[${index}].description must be a non-empty string`);
+            return;
+        }
+        const scoreType = (0, types_1.parseAppLeaderboardScoreType)(entry.scoreType);
+        if (!scoreType) {
+            errors.push(`leaderboards[${index}].scoreType must be one of ${types_1.APP_LEADERBOARD_SCORE_TYPE_VALUES.join(', ')}`);
+            return;
+        }
+        const sort = (0, types_1.parseAppLeaderboardSort)(entry.sort);
+        if (!sort) {
+            errors.push(`leaderboards[${index}].sort must be one of ${types_1.APP_LEADERBOARD_SORT_VALUES.join(', ')}`);
+            return;
+        }
+        if (!(0, types_1.isValidLeaderboardDefinitionCombination)(scoreType, sort)) {
+            errors.push(`leaderboards[${index}] must use INTEGER + DESC or TIME_MS + ASC`);
+            return;
+        }
+        const status = (0, types_1.parsePlayerMetaDefinitionStatus)(entry.status ?? 'ACTIVE');
+        if (!status) {
+            errors.push(`leaderboards[${index}].status must be one of ${types_1.PLAYER_META_DEFINITION_STATUS_VALUES.join(', ')}`);
+            return;
+        }
+        const unitLabel = typeof entry.unitLabel === 'string' && entry.unitLabel.trim().length > 0
+            ? entry.unitLabel.trim()
+            : undefined;
+        definitions.push({
+            key,
+            displayName,
+            description,
+            scoreType,
+            sort,
+            ...(unitLabel ? { unitLabel } : {}),
+            status,
+        });
+    });
+    return definitions;
+}
 function validateAppMetadata(entry) {
     const warnings = [];
     const errors = [];
@@ -592,6 +749,12 @@ function buildAppTasks(rootDir, catalogues, options) {
             if (metadata.warnings.length > 0) {
                 warnings.push(`${label} (${metadata.warnings.join('; ')})`);
             }
+            const errorCountBeforePlayerMeta = errors.length;
+            const achievements = validateAchievementDefinitions(entry.achievements, file.directory, errors);
+            const leaderboards = validateLeaderboardDefinitions(entry.leaderboards, errors);
+            if (errors.length > errorCountBeforePlayerMeta) {
+                continue;
+            }
             if (isTypescriptProject && !hasValidateScript) {
                 warnings.push(`${label} (${rawName}: package.json missing "validate" script)`);
             }
@@ -667,6 +830,32 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 hostingMode = rawHostingMode;
             }
+            let authMode;
+            const rawAuthMode = typeof entry.authMode === 'string' ? entry.authMode.trim().toUpperCase() : '';
+            if (rawAuthMode) {
+                if (!types_1.APP_AUTH_MODE_VALUES.includes(rawAuthMode)) {
+                    errors.push(`[${label}] Skipping ${rawName}: authMode must be one of ${types_1.APP_AUTH_MODE_VALUES.join(', ')}.`);
+                    continue;
+                }
+                authMode = rawAuthMode;
+            }
+            let controllerMode;
+            const rawControllerMode = typeof entry.controllerMode === 'string' ? entry.controllerMode.trim().toUpperCase() : '';
+            if (rawControllerMode) {
+                if (!types_1.APP_CONTROLLER_MODE_VALUES.includes(rawControllerMode)) {
+                    errors.push(`[${label}] Skipping ${rawName}: controllerMode must be one of ${types_1.APP_CONTROLLER_MODE_VALUES.join(', ')}.`);
+                    continue;
+                }
+                controllerMode = rawControllerMode;
+            }
+            let previewable;
+            if (Object.prototype.hasOwnProperty.call(entry, 'previewable')) {
+                if (typeof entry.previewable !== 'boolean') {
+                    errors.push(`[${label}] Skipping ${rawName}: previewable must be true or false.`);
+                    continue;
+                }
+                previewable = Boolean(entry.previewable);
+            }
             let externalUrl;
             const rawExternalUrl = typeof entry.externalUrl === 'string' ? entry.externalUrl.trim() : '';
             if (rawExternalUrl) {
@@ -685,6 +874,10 @@ function buildAppTasks(rootDir, catalogues, options) {
                 // Auto-set hostingMode to EXTERNAL if externalUrl is provided
                 hostingMode = 'EXTERNAL';
             }
+            if ((hostingMode ?? 'HOSTED') === 'EXTERNAL' && previewable) {
+                errors.push(`[${label}] Skipping ${rawName}: previewable can only be true for HOSTED apps.`);
+                continue;
+            }
             // Parse username field (admin-only)
             let username;
             const rawUsername = typeof entry.username === 'string' ? entry.username.trim() : '';
@@ -981,10 +1174,15 @@ function buildAppTasks(rootDir, catalogues, options) {
                 releaseNotes,
                 versionVisibility,
                 hostingMode,
+                authMode,
+                controllerMode,
+                previewable,
                 externalUrl,
                 listing,
                 // Admin-only field
                 username,
+                achievements,
+                leaderboards,
                 remix,
                 embeddedAssets,
                 uses: {

package/dist/commands/changelog.d.ts

@@ -0,0 +1 @@
+export declare function showChangelog(): Promise<void>;

package/dist/commands/changelog.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showChangelog = showChangelog;
+const publicPages_1 = require("./publicPages");
+async function showChangelog() {
+    await (0, publicPages_1.showPublicPage)('changelog', 'app-pages/changelog.md');
+}

package/dist/commands/create.js

@@ -537,6 +537,8 @@ function buildPendingExternalRemixTask(name, metadata, sourceInfo, cataloguePath
         missingMetadata: [],
         version: entry.version,
         remix: typeof entry.remix === 'string' ? entry.remix : undefined,
+        achievements: [],
+        leaderboards: [],
         embeddedAssets: [],
         uses: { assets: [], packs: [] },
         graph: { relations: [] },

package/dist/commands/documentation.js

@@ -22,6 +22,23 @@ function normalizeDocPath(value) {
     }
     return segments.join('/');
 }
+function toDisplayDocPath(entry) {
+    if (entry.endsWith('/README.md')) {
+        return entry.slice(0, -'/README.md'.length);
+    }
+    if (entry.endsWith('/AGENTS.md')) {
+        return `${entry.slice(0, -'/AGENTS.md'.length)}/agents`;
+    }
+    return entry;
+}
+function createDocAliasMap(entries) {
+    const aliases = new Map();
+    for (const entry of entries) {
+        aliases.set(entry, entry);
+        aliases.set(toDisplayDocPath(entry), entry);
+    }
+    return aliases;
+}
 function encodePathSegments(pathValue) {
     return pathValue
         .split('/')
@@ -68,7 +85,8 @@ async function browseDocumentation(options = {}) {
         if (!entries) {
             return;
         }
-        const items = [...new Set(entries.map((entry) => normalizeDocPath(entry)).filter((entry) => Boolean(entry)))].sort((a, b) => a.localeCompare(b));
+        const normalizedEntries = [...new Set(entries.map((entry) => normalizeDocPath(entry)).filter((entry) => Boolean(entry)))].sort((a, b) => a.localeCompare(b));
+        const items = [...new Set(normalizedEntries.map((entry) => toDisplayDocPath(entry)))].sort((a, b) => a.localeCompare(b));
         if (options.json) {
             (0, output_1.printJson)({ items });
             return;
@@ -87,7 +105,7 @@ async function browseDocumentation(options = {}) {
 async function readDocumentation(pathArg) {
     const normalizedTarget = normalizeDocPath(pathArg);
     if (!normalizedTarget) {
-        (0, messages_1.printErrorWithHelp)('A documentation path is required.', ['Use a relative path such as sdk/getting-started.md.', 'Run "playdrop documentation browse" to list available entries.'], { command: 'documentation read' });
+        (0, messages_1.printErrorWithHelp)('A documentation path is required.', ['Use a relative path such as runtime.', 'Run "playdrop documentation browse" to list available entries.'], { command: 'documentation read' });
         process.exitCode = 1;
         return;
     }
@@ -102,12 +120,14 @@ async function readDocumentation(pathArg) {
             return;
         }
         const normalizedEntries = [...new Set(entries.map((entry) => normalizeDocPath(entry)).filter((entry) => Boolean(entry)))];
-        if (!normalizedEntries.includes(normalizedTarget)) {
+        const aliases = createDocAliasMap(normalizedEntries);
+        const resolvedTarget = aliases.get(normalizedTarget);
+        if (!resolvedTarget) {
             (0, messages_1.printErrorWithHelp)(`Documentation entry "${normalizedTarget}" was not found.`, ['Run "playdrop documentation browse" to list available entries.'], { command: 'documentation read' });
             process.exitCode = 1;
             return;
         }
-        const fileUrl = buildDocumentationFileUrl(envConfig.cdnBase, normalizedTarget);
+        const fileUrl = buildDocumentationFileUrl(envConfig.cdnBase, resolvedTarget);
         let response;
         try {
             response = await fetch(fileUrl);

package/dist/commands/publicPages.d.ts

@@ -0,0 +1 @@
+export declare function showPublicPage(command: string, relativePath: string): Promise<void>;

package/dist/commands/publicPages.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showPublicPage = showPublicPage;
+const commandContext_1 = require("../commandContext");
+const messages_1 = require("../messages");
+function buildPublicPageUrl(base, relativePath) {
+    return `${base.replace(/\/$/, '')}/${relativePath}`;
+}
+async function showPublicPage(command, relativePath) {
+    await (0, commandContext_1.withPublicEnvironment)(command, async ({ envConfig }) => {
+        if (!envConfig.cdnBase) {
+            (0, messages_1.printErrorWithHelp)(`Environment "${envConfig.name}" does not include a public content base URL.`, ['Set PLAYDROP_CDN_BASE or use an environment that publishes public content assets.'], { command });
+            process.exitCode = 1;
+            return;
+        }
+        let response;
+        try {
+            response = await fetch(buildPublicPageUrl(envConfig.cdnBase, relativePath));
+        }
+        catch (error) {
+            (0, messages_1.printErrorWithHelp)(`Fetching ${command} failed.`, [error instanceof Error ? error.message : String(error)], { command });
+            process.exitCode = 1;
+            return;
+        }
+        if (!response.ok) {
+            (0, messages_1.printErrorWithHelp)(`Failed to fetch ${command}.`, [`HTTP ${response.status} ${response.statusText}`], { command });
+            process.exitCode = 1;
+            return;
+        }
+        process.stdout.write(await response.text());
+    });
+}

package/dist/index.js

@@ -30,7 +30,8 @@ const format_1 = require("./commands/format");
 const upload_1 = require("./commands/upload");
 const documentation_1 = require("./commands/documentation");
 const feedback_1 = require("./commands/feedback");
-const gettingStarted_1 = require("./commands/gettingStarted");
+const changelog_1 = require("./commands/changelog");
+const publicPages_1 = require("./commands/publicPages");
 const upgrade_1 = require("./commands/upgrade");
 const messages_1 = require("./messages");
 function resolveInitTarget(pathArg) {
@@ -83,7 +84,7 @@ program
     .addHelpCommand('help [command]', 'Show help for a command');
 program.showHelpAfterError();
 program.showSuggestionAfterError();
-program.addHelpText('afterAll', '\nStart here: run `playdrop getting-started`.\n');
+program.addHelpText('afterAll', '\nStart here: run `playdrop getting-started`, `playdrop faq`, or `playdrop changelog`.\n');
 program.on('command:*', (unknownCommands) => {
     const [unknownCommand] = unknownCommands;
     if (unknownCommand) {
@@ -648,14 +649,26 @@ feedback
 program
     .command('getting-started')
     .description('Show the recommended first steps')
-    .action(() => {
-    (0, gettingStarted_1.printGettingStarted)();
+    .action(async () => {
+    await (0, publicPages_1.showPublicPage)('getting-started', 'app-pages/getting-started.md');
+});
+program
+    .command('faq')
+    .description('Show creator-focused platform questions and answers')
+    .action(async () => {
+    await (0, publicPages_1.showPublicPage)('faq', 'app-pages/faq.md');
+});
+program
+    .command('changelog')
+    .description('Read the latest public Playdrop changelog')
+    .action(async () => {
+    await (0, changelog_1.showChangelog)();
 });
 program
     .command('start')
     .description('Alias of getting-started')
-    .action(() => {
-    (0, gettingStarted_1.printGettingStarted)();
+    .action(async () => {
+    await (0, publicPages_1.showPublicPage)('getting-started', 'app-pages/getting-started.md');
 });
 program
     .command('update')

package/dist/sessionCookie.d.ts

@@ -0,0 +1,18 @@
+export declare function resolveCaptureSessionCookieDomain(hostname: string): string | null;
+export declare function shouldUseSecureCaptureSessionCookie(hostname: string): boolean;
+export declare function buildCaptureAccessTokenCookies(targetUrl: string, accessToken: string): {
+    name: string;
+    value: string;
+    url: string;
+    httpOnly: boolean;
+    sameSite: "Lax";
+    secure: boolean;
+}[] | {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    httpOnly: boolean;
+    sameSite: "Lax";
+    secure: boolean;
+}[];