autokap 1.4.3 → 1.5.2

package/dist/cli-contract.d.ts

@@ -7,6 +7,7 @@ export interface CliPublicCommandDescriptor {
 export declare const CLI_KEY_TERM = "CLI key";
 export declare const CLI_VERSION_HEADER = "x-autokap-cli-version";
 export declare const MIN_CLI_VERSION_FOR_SIGNED_PROGRAMS = "1.0.9";
+export declare const MIN_CLI_VERSION_FOR_DIRECT_ARTIFACT_UPLOADS = "1.5.0";
 export declare const CLI_DEFAULT_INSTALL_COMMAND = "npm install -g autokap";
 export declare const CLI_DEFAULT_INSTALLED_SETUP_COMMAND = "autokap init --cli-key <your-cli-key>";
 export declare const CLI_DEFAULT_SETUP_COMMAND = "npx autokap@latest init --cli-key <your-cli-key>";
@@ -51,6 +52,12 @@ export interface VideoClipMetadata {
             width: number;
             height: number;
         } | null;
+        /**
+         * For TYPE opcodes captured in clipCursor mode: clip-relative ms timestamp
+         * of every keystroke produced by `humanType`. Drives per-keystroke keyboard
+         * SFX in the video compositor.
+         */
+        keystrokeOffsetsMs?: number[];
     }>;
 }
 export interface VideoAudioAsset {
@@ -79,4 +86,76 @@ export interface VideoCompletePayload {
 export interface VideoCompleteResponse {
     composeRunId: string;
     composeRunIds?: string[];
+    compositorTrigger?: {
+        triggered: boolean;
+        operationName?: string;
+        skippedReason?: string;
+        error?: string;
+    };
+}
+export type ArtifactUploadObjectId = "screenshotRaw" | "screenshot" | "clipGif" | "clipMp4" | "clipThumbnail" | "videoMp4" | "tabIcon";
+export interface ArtifactUploadMetadata {
+    presetId: string;
+    runId: string;
+    variantId: string;
+    targetId?: string | null;
+    targetLabel?: string | null;
+    programVersion?: number | null;
+    compileFingerprint?: string | null;
+    mediaMode: "screenshot" | "clip" | "video";
+    mimeType: string;
+    captureType: "fullpage" | "element";
+    captureUrl: string;
+    lang: string;
+    theme: "light" | "dark";
+    deviceFrame?: string | null;
+    deviceScaleFactor?: number | null;
+    viewport?: {
+        width: number;
+        height: number;
+    } | null;
+    altText?: string | null;
+    elementSelector?: string | null;
+    captureId?: string | null;
+    captureName?: string | null;
+    clipId?: string | null;
+    clipName?: string | null;
+    stepDescription?: string | null;
+    stepIndex?: number | null;
+    durationMs?: number | null;
+    trimStartMs?: number | null;
+    artifactPlan?: Record<string, unknown> | null;
+    tabIconMimeType?: string | null;
+    tabIconSha256?: string | null;
+}
+export interface ArtifactUploadTarget {
+    id: ArtifactUploadObjectId;
+    bucket: "screenshots" | "videos";
+    path: string;
+    contentType: string;
+    method: "PUT";
+    signedUrl: string;
+    token?: string;
+    expiresAt: string;
+}
+export interface ArtifactUploadInitRequest {
+    metadata: ArtifactUploadMetadata;
+}
+export interface ArtifactUploadInitResponse {
+    uploadId: string;
+    uploads: ArtifactUploadTarget[];
+    expiresAt: string;
+}
+export interface ArtifactUploadedObject {
+    id: ArtifactUploadObjectId;
+    bucket: "screenshots" | "videos";
+    path: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+}
+export interface ArtifactUploadCompleteRequest {
+    uploadId: string;
+    metadata: ArtifactUploadMetadata;
+    objects: ArtifactUploadedObject[];
 }

package/dist/cli-contract.js

@@ -1,6 +1,7 @@
 export const CLI_KEY_TERM = "CLI key";
 export const CLI_VERSION_HEADER = "x-autokap-cli-version";
 export const MIN_CLI_VERSION_FOR_SIGNED_PROGRAMS = "1.0.9";
+export const MIN_CLI_VERSION_FOR_DIRECT_ARTIFACT_UPLOADS = "1.5.0";
 export const CLI_DEFAULT_INSTALL_COMMAND = "npm install -g autokap";
 export const CLI_DEFAULT_INSTALLED_SETUP_COMMAND = "autokap init --cli-key <your-cli-key>";
 export const CLI_DEFAULT_SETUP_COMMAND = "npx autokap@latest init --cli-key <your-cli-key>";

package/dist/cli-doctor.d.ts

@@ -0,0 +1,4 @@
+export declare function runDoctor(opts: {
+    fix: boolean;
+    agent?: string;
+}, currentVersion: string): Promise<void>;

package/dist/cli-doctor.js

@@ -0,0 +1,302 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { chromium } from 'playwright';
+import { logger } from './logger.js';
+import { ensureFfmpegAvailable } from './clip-postprocess.js';
+import { readConfig, getConfigPath } from './cli-config.js';
+import { getCachedOrFetchLatest, isNewerVersion } from './version-check.js';
+import { writeSkillExport } from './skill-packaging.js';
+const REQUIRED_NODE_MAJOR = 20;
+const AGENT_PATHS = {
+    claude: '.claude/commands/autokap-preset.md',
+    codex: '.agents/skills/autokap-preset/SKILL.md',
+    cursor: '.cursor/rules/autokap-preset.md',
+    windsurf: '.windsurf/rules/autokap-preset.md',
+    copilot: '.github/instructions/autokap-preset.instructions.md',
+};
+async function pathExists(candidate) {
+    try {
+        await fs.access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkNodeVersion() {
+    const major = Number.parseInt(process.version.slice(1).split('.')[0], 10);
+    if (Number.isFinite(major) && major >= REQUIRED_NODE_MAJOR) {
+        return {
+            name: 'Node.js',
+            status: 'ok',
+            message: `${process.version} (>= ${REQUIRED_NODE_MAJOR} required)`,
+        };
+    }
+    return {
+        name: 'Node.js',
+        status: 'fail',
+        message: `${process.version} is too old. Node ${REQUIRED_NODE_MAJOR}+ is required.`,
+        fixCommand: 'Install Node 20+ via nvm (`nvm install 20`), Homebrew (`brew install node`), or https://nodejs.org',
+    };
+}
+async function checkChromium() {
+    let executablePath = null;
+    try {
+        executablePath = chromium.executablePath();
+    }
+    catch {
+        executablePath = null;
+    }
+    if (executablePath && (await pathExists(executablePath))) {
+        return {
+            name: 'Chromium (Playwright)',
+            status: 'ok',
+            message: executablePath,
+        };
+    }
+    const installCommand = 'npx playwright install chromium';
+    return {
+        name: 'Chromium (Playwright)',
+        status: 'fail',
+        message: 'Chromium binary not found. Required for local capture (`autokap run`).',
+        fixCommand: installCommand,
+        fixFn: async () => {
+            await runCommandStreaming('npx', ['playwright', 'install', 'chromium']);
+        },
+    };
+}
+async function checkFfmpeg() {
+    try {
+        const resolved = await ensureFfmpegAvailable();
+        return {
+            name: 'ffmpeg',
+            status: 'ok',
+            message: resolved,
+        };
+    }
+    catch {
+        const installCommand = ffmpegInstallCommandForPlatform();
+        return {
+            name: 'ffmpeg',
+            status: 'warn',
+            message: 'ffmpeg not found. Required only for clip post-processing (gif/mp4/webm).',
+            fixCommand: installCommand,
+        };
+    }
+}
+function ffmpegInstallCommandForPlatform() {
+    switch (process.platform) {
+        case 'darwin':
+            return 'brew install ffmpeg';
+        case 'linux':
+            return 'sudo apt install ffmpeg  # or your distro equivalent';
+        case 'win32':
+            return 'choco install ffmpeg  # or download from https://ffmpeg.org';
+        default:
+            return 'Install ffmpeg from https://ffmpeg.org';
+    }
+}
+async function checkConfig() {
+    let config = null;
+    try {
+        config = await readConfig();
+    }
+    catch (err) {
+        return {
+            name: 'CLI configuration',
+            status: 'fail',
+            message: `Failed to read config: ${err.message}`,
+            fixCommand: 'autokap init --cli-key <key>',
+        };
+    }
+    if (!config) {
+        return {
+            name: 'CLI configuration',
+            status: 'fail',
+            message: `No API key found. Checked AUTOKAP_RUN_TOKEN, AUTOKAP_API_KEY, and ${getConfigPath()}.`,
+            fixCommand: 'autokap init --cli-key <key>',
+        };
+    }
+    if (!config.apiKey) {
+        return {
+            name: 'CLI configuration',
+            status: 'fail',
+            message: 'Config exists but apiKey is empty.',
+            fixCommand: 'autokap init --cli-key <key>',
+        };
+    }
+    return {
+        name: 'CLI configuration',
+        status: 'ok',
+        message: `apiBaseUrl=${config.apiBaseUrl}`,
+    };
+}
+async function detectAgent() {
+    const detectors = [
+        ['.claude', 'claude'],
+        ['.agents', 'codex'],
+        ['.cursor', 'cursor'],
+        ['.windsurf', 'windsurf'],
+        ['.github/instructions', 'copilot'],
+    ];
+    for (const [dir, key] of detectors) {
+        if (await pathExists(path.join(process.cwd(), dir))) {
+            return key;
+        }
+    }
+    return null;
+}
+async function checkSkill(agentOverride) {
+    const agent = agentOverride ?? (await detectAgent());
+    if (!agent) {
+        return {
+            name: 'AI agent skill',
+            status: 'warn',
+            message: 'No agent directory detected (.claude, .agents, .cursor, .windsurf, .github/instructions). Skipping skill check.',
+            fixCommand: 'autokap init  # or autokap skill --agent <name> to install',
+        };
+    }
+    const skillPath = path.join(process.cwd(), AGENT_PATHS[agent]);
+    if (await pathExists(skillPath)) {
+        return {
+            name: 'AI agent skill',
+            status: 'ok',
+            message: `${agent}: ${AGENT_PATHS[agent]}`,
+        };
+    }
+    return {
+        name: 'AI agent skill',
+        status: 'warn',
+        message: `${agent} agent detected but skill is missing at ${AGENT_PATHS[agent]}.`,
+        fixCommand: `autokap skill --agent ${agent}`,
+        fixFn: async () => {
+            await writeSkillExport({
+                type: 'preset',
+                agent,
+                outputPath: AGENT_PATHS[agent],
+                placeholders: {},
+            });
+        },
+    };
+}
+async function checkCliVersion(currentVersion) {
+    const latest = await getCachedOrFetchLatest();
+    if (!latest) {
+        return {
+            name: 'CLI version',
+            status: 'warn',
+            message: `${currentVersion} (latest version check unavailable — offline?)`,
+        };
+    }
+    if (isNewerVersion(latest, currentVersion)) {
+        return {
+            name: 'CLI version',
+            status: 'warn',
+            message: `${currentVersion} installed, ${latest} available.`,
+            fixCommand: 'npm install -g autokap@latest',
+        };
+    }
+    return {
+        name: 'CLI version',
+        status: 'ok',
+        message: `${currentVersion} (latest)`,
+    };
+}
+function runCommandStreaming(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('exit', code => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`));
+        });
+    });
+}
+function statusBadge(status) {
+    switch (status) {
+        case 'ok':
+            return chalk.green('✓');
+        case 'warn':
+            return chalk.yellow('⚠');
+        case 'fail':
+            return chalk.red('✗');
+    }
+}
+function statusLabel(status) {
+    switch (status) {
+        case 'ok':
+            return chalk.green('OK');
+        case 'warn':
+            return chalk.yellow('WARN');
+        case 'fail':
+            return chalk.red('FAIL');
+    }
+}
+function printCheck(result) {
+    console.log(`${statusBadge(result.status)} ${chalk.bold(result.name)} ${chalk.gray('—')} ${statusLabel(result.status)}`);
+    console.log(`  ${result.message}`);
+    if (result.fixCommand && result.status !== 'ok') {
+        console.log(`  ${chalk.gray('Fix:')} ${chalk.cyan(result.fixCommand)}`);
+    }
+    console.log('');
+}
+export async function runDoctor(opts, currentVersion) {
+    const agentOverride = opts.agent
+        ? opts.agent.toLowerCase()
+        : undefined;
+    if (agentOverride && !(agentOverride in AGENT_PATHS)) {
+        logger.error(`Unknown agent "${opts.agent}". Supported: ${Object.keys(AGENT_PATHS).join(', ')}`);
+        process.exit(1);
+    }
+    console.log(chalk.bold('\nautokap doctor'));
+    console.log(chalk.gray(`Checking environment for autokap ${currentVersion}...\n`));
+    const results = [];
+    results.push(checkNodeVersion());
+    results.push(await checkChromium());
+    results.push(await checkFfmpeg());
+    results.push(await checkConfig());
+    results.push(await checkSkill(agentOverride));
+    results.push(await checkCliVersion(currentVersion));
+    for (const r of results) {
+        printCheck(r);
+    }
+    const failures = results.filter(r => r.status === 'fail');
+    const warnings = results.filter(r => r.status === 'warn');
+    if (opts.fix) {
+        const fixable = results.filter(r => r.status !== 'ok' && r.fixFn);
+        if (fixable.length === 0) {
+            if (failures.length === 0 && warnings.length === 0) {
+                logger.success('All checks passed. Nothing to fix.');
+            }
+            else {
+                logger.info('No auto-fixable issues. See suggested commands above.');
+            }
+        }
+        else {
+            console.log(chalk.bold(`Attempting to fix ${fixable.length} issue(s)...\n`));
+            for (const r of fixable) {
+                console.log(chalk.cyan(`→ ${r.name}`));
+                try {
+                    await r.fixFn();
+                    logger.success(`Fixed: ${r.name}`);
+                }
+                catch (err) {
+                    logger.error(`Failed to fix ${r.name}: ${err.message}`);
+                }
+                console.log('');
+            }
+            logger.info('Re-run `autokap doctor` to verify the fixes.');
+        }
+    }
+    const summary = `${results.filter(r => r.status === 'ok').length} OK, ${warnings.length} warning(s), ${failures.length} failure(s)`;
+    console.log(chalk.bold(`Summary: ${summary}`));
+    process.exit(failures.length > 0 ? 1 : 0);
+}
+//# sourceMappingURL=cli-doctor.js.map