autokap 1.0.7 → 1.0.10

package/dist/program-signing.js

@@ -0,0 +1,140 @@
+import crypto from 'node:crypto';
+import { z } from 'zod';
+import { ExecutionProgramSchema } from './execution-schema.js';
+const MAX_SIGNATURE_AGE_MS = 15 * 60 * 1000;
+const FUTURE_SKEW_MS = 60 * 1000;
+function isHttpOrigin(value) {
+    try {
+        const parsed = new URL(value);
+        return ((parsed.protocol === 'http:' || parsed.protocol === 'https:')
+            && parsed.origin === value
+            && Boolean(parsed.host));
+    }
+    catch {
+        return false;
+    }
+}
+const HttpOriginSchema = z.string().refine(isHttpOrigin, {
+    message: 'Expected an exact http/https origin',
+});
+export const ProgramSecurityMetadataSchema = z.object({
+    expectedApiOrigin: HttpOriginSchema,
+    allowedNavigationOrigins: z.array(HttpOriginSchema).min(1),
+    runtimeLlmAllowed: z.boolean().default(false),
+}).strict();
+export const SignedExecutionProgramEnvelopeSchema = z.object({
+    kind: z.literal('signed_execution_program'),
+    signedAt: z.string().datetime(),
+    security: ProgramSecurityMetadataSchema,
+    program: ExecutionProgramSchema,
+    signature: z.string().regex(/^[a-f0-9]{64}$/i),
+    meta: z.object({
+        stale: z.boolean().optional(),
+    }).strict().optional(),
+}).strict();
+function stableNormalize(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => stableNormalize(entry));
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => [key, stableNormalize(entry)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(stableNormalize(value));
+}
+function signPayload(payload, apiKey) {
+    return crypto
+        .createHmac('sha256', apiKey)
+        .update(stableStringify(payload))
+        .digest('hex');
+}
+export function normalizeAllowedOrigins(origins) {
+    const unique = new Set();
+    for (const origin of origins) {
+        if (!origin)
+            continue;
+        const normalized = normalizeHttpOrigin(origin);
+        if (normalized)
+            unique.add(normalized);
+    }
+    return Array.from(unique).sort();
+}
+export function normalizeHttpOrigin(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return null;
+        }
+        if (!parsed.host)
+            return null;
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function signExecutionProgramEnvelope(params) {
+    const signedAt = params.signedAt ?? new Date().toISOString();
+    const payload = {
+        signedAt,
+        security: {
+            ...params.security,
+            allowedNavigationOrigins: normalizeAllowedOrigins(params.security.allowedNavigationOrigins),
+        },
+        program: params.program,
+    };
+    return {
+        kind: 'signed_execution_program',
+        signedAt,
+        security: payload.security,
+        program: payload.program,
+        signature: signPayload(payload, params.apiKey),
+        ...(params.meta ? { meta: params.meta } : {}),
+    };
+}
+export function verifySignedExecutionProgramEnvelope(params) {
+    const envelope = SignedExecutionProgramEnvelopeSchema.parse(params.envelope);
+    const payload = {
+        signedAt: envelope.signedAt,
+        security: {
+            ...envelope.security,
+            allowedNavigationOrigins: normalizeAllowedOrigins(envelope.security.allowedNavigationOrigins),
+        },
+        program: envelope.program,
+    };
+    const expectedSignature = signPayload(payload, params.apiKey);
+    const received = Buffer.from(envelope.signature, 'hex');
+    const expected = Buffer.from(expectedSignature, 'hex');
+    if (received.length !== expected.length || !crypto.timingSafeEqual(received, expected)) {
+        throw new Error('program signature verification failed');
+    }
+    const expectedOrigin = normalizeHttpOrigin(params.expectedApiOrigin);
+    if (expectedOrigin && payload.security.expectedApiOrigin !== expectedOrigin) {
+        throw new Error(`program expected API origin ${payload.security.expectedApiOrigin}, received via ${expectedOrigin}`);
+    }
+    const now = params.now ?? new Date();
+    const signedAt = Date.parse(envelope.signedAt);
+    if (!Number.isFinite(signedAt)) {
+        throw new Error('program signature timestamp is invalid');
+    }
+    if (signedAt - now.getTime() > FUTURE_SKEW_MS) {
+        throw new Error('program signature timestamp is in the future');
+    }
+    if (now.getTime() - signedAt > MAX_SIGNATURE_AGE_MS) {
+        throw new Error('program signature has expired');
+    }
+    return {
+        ...envelope,
+        security: payload.security,
+    };
+}
+//# sourceMappingURL=program-signing.js.map

package/dist/prompts.d.ts

@@ -1,5 +1,5 @@
 import type { ChatCompletionContentPart } from 'openai/resources/chat/completions';
-import type { AgentConfig, AgentRunHint, CaptureCursor, CaptureObjective, CaptureHandoffContext, ExecutedAction, InteractiveElement, LoginCredentials, RepairTicket, VariantCaptureManifest, ValidatedSessionProfile, WorkflowScreenshot } from './types.js';
+import type { AgentConfig, AgentRunHint, CaptureCursor, CaptureObjective, CaptureHandoffContext, ExecutedAction, InteractiveElement, LoginCredentials, OverlayScopeSummary, RepairTicket, VariantCaptureManifest, ValidatedSessionProfile, WorkflowScreenshot } from './types.js';
 interface SystemPromptOptions {
     reasoningLocale?: string;
 }
@@ -29,6 +29,7 @@ export interface StableAnchorUserMessageParams {
 }
 export interface IterationUserMessageParams {
     userPrompt: string;
+    serializedAKTree: string;
     cleanScreenshotUrl?: string;
     screenshotUrl: string;
     /** In dual-model mode, the vision model's text observation replaces images. */
@@ -107,6 +108,10 @@ export interface IterationUserMessageParams {
     };
     /** Compact summary of recent failed actions — prevents the agent from repeating dead-end strategies. */
     failedAttemptsSummary?: string;
+    /** When true, the browser is already on the target URL — the agent should check and capture, not navigate. */
+    alreadyOnTarget?: boolean;
+    promptFingerprint?: string;
+    overlayScope?: OverlayScopeSummary | null;
 }
 export declare function buildStableAnchorUserMessage(params: StableAnchorUserMessageParams): {
     content: ChatCompletionContentPart[];
@@ -140,6 +145,7 @@ export declare function buildVisionObserverPrompt(params: {
     currentUrl: string;
     interactiveElements: InteractiveElement[];
     userGoal: string;
+    question?: string;
     currentLang?: string;
     currentTheme?: 'light' | 'dark';
     currentPageId?: string;
@@ -150,9 +156,7 @@ export declare function buildElementSystemPrompt(description: string): string;
 export declare function buildElementIterationMessage(params: {
     elementName: string;
     elementDescription: string;
-    accessibilityTree: string;
-    interactiveElements: InteractiveElement[];
-    simplifiedDOM?: string;
+    serializedAKTree: string;
     currentUrl: string;
     iteration: number;
     maxIterations: number;
@@ -161,7 +165,11 @@ export declare function buildElementIterationMessage(params: {
         width: number;
         height: number;
     };
-    forbiddenSearchQueries?: string[];
+    scrollInfo?: {
+        scrollY: number;
+        scrollHeight: number;
+        viewportHeight: number;
+    };
     screenshotUrl?: string;
 }): ChatCompletionContentPart[];
 export {};