unbrowse 2.12.2 → 2.12.7

package/runtime-src/orchestrator/first-pass-action.ts

@@ -1,362 +0,0 @@
-import * as kuri from "../kuri/client.js";
-import type { KuriHarEntry } from "../kuri/client.js";
-import { createHash } from "node:crypto";
-import type { EndpointDescriptor, SkillManifest } from "../types/skill.js";
-
-export type IntentClass = "search" | "navigate" | "click" | "submit" | "read" | "unknown";
-
-export interface FirstPassResult {
-  intentClass: IntentClass;
-  actionTaken: string;
-  hit: boolean;
-  interceptedEntries: KuriHarEntry[];
-  miniSkill?: SkillManifest;
-  result?: unknown;
-  timeMs: number;
-  /** Tab ID kept alive on miss for Phase 4 agentic loop to reuse */
-  tabId?: string;
-}
-
-interface FirstPassOptions {
-  signal?: AbortSignal;
-  clientScope?: string;
-}
-
-/** Classify an intent string into an action category. */
-export function classifyIntent(intent: string): IntentClass {
-  if (/\b(search|find|discover|look\s+for|browse)\b/i.test(intent)) return "search";
-  if (/\b(go\s+to|open|visit|navigate)\b/i.test(intent)) return "navigate";
-  if (/\b(click|tap|press|select)\b/i.test(intent)) return "click";
-  if (/\b(submit|register|sign\s+up|rsvp|book|apply)\b/i.test(intent)) return "submit";
-  if (/\b(read|get|fetch|show|list|view)\b/i.test(intent)) return "read";
-  return "unknown";
-}
-
-/** Map an intent class to a browser action descriptor. */
-export function classifyAction(
-  intentClass: IntentClass,
-  _url: string,
-): { type: "search" | "click" | "navigate" | "wait"; selector?: string } {
-  switch (intentClass) {
-    case "search":
-      return {
-        type: "search",
-        selector: "input[type=search],input[name=q],input[name=query],input[name=search]",
-      };
-    case "submit":
-      return {
-        type: "click",
-        selector: "button[type=submit],input[type=submit],[role=button]",
-      };
-    case "click":
-      return { type: "click", selector: "[role=button],button,a" };
-    case "navigate":
-    case "read":
-    case "unknown":
-    default:
-      return { type: "navigate" };
-  }
-}
-
-/** Filter HAR entries to only JSON API responses with 2xx status. */
-function filterJsonApiEntries(entries: KuriHarEntry[]): KuriHarEntry[] {
-  return entries.filter((entry) => {
-    const status = entry.response?.status;
-    if (!status || status < 200 || status > 299) return false;
-    const ct =
-      (entry.response.headers ?? []).find(
-        (h) => h.name.toLowerCase() === "content-type",
-      )?.value ?? "";
-    return ct.includes("application/json") || ct.includes("+json");
-  });
-}
-
-/** Build a lightweight skill manifest from intercepted HAR entries. */
-export function synthesizeSkillFromIntercepted(
-  interceptedEntries: KuriHarEntry[],
-  domain: string,
-  intent: string,
-): SkillManifest | undefined {
-  if (interceptedEntries.length === 0) return undefined;
-
-  const hash = createHash("sha1")
-    .update(interceptedEntries.map((e) => e.request.url).join("|"))
-    .digest("hex")
-    .slice(0, 8);
-
-  const endpoints: EndpointDescriptor[] = interceptedEntries.map((entry, i) => {
-    const parsed = new URL(entry.request.url);
-    return {
-      endpoint_id: `fp-ep-${i}`,
-      method: entry.request.method.toUpperCase() as EndpointDescriptor["method"],
-      url_template: parsed.origin + parsed.pathname,
-      idempotency: "safe" as const,
-      verification_status: "unverified" as const,
-      reliability_score: 0.5,
-      description: `First-pass intercepted endpoint for intent: ${intent}`,
-    };
-  });
-
-  return {
-    skill_id: `first-pass-${domain}-${hash}`,
-    version: "0.0.1",
-    schema_version: "2",
-    name: `First-pass: ${domain}`,
-    intent_signature: intent,
-    domain,
-    description: "Lightweight first-pass skill synthesized from intercepted network requests",
-    owner_type: "agent",
-    execution_type: "http",
-    lifecycle: "active",
-    endpoints,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-  };
-}
-
-/**
- * Lightweight first-pass browser action: navigate to contextUrl, optionally
- * perform an intent-driven action (search / click), collect intercepted
- * JSON API requests via HAR recording, and return them for passive indexing.
- *
- * Designed to complete within ~5-8s. On any error, returns hit:false
- * and never throws.
- */
-export async function tryFirstPassBrowserAction(
-  intent: string,
-  params: Record<string, unknown>,
-  contextUrl: string,
-  options?: FirstPassOptions,
-): Promise<FirstPassResult> {
-  const t0 = Date.now();
-  const intentClass = classifyIntent(intent);
-  const action = classifyAction(intentClass, contextUrl);
-
-  let domain = "";
-  try {
-    domain = new URL(contextUrl).hostname;
-  } catch {
-    domain = "unknown";
-  }
-
-  // Hard 8s timeout for the entire operation
-  const timeoutMs = 8_000;
-  const deadline = t0 + timeoutMs;
-  const externalSignal = options?.signal;
-
-  function isAborted(): boolean {
-    if (externalSignal?.aborted) return true;
-    return Date.now() >= deadline;
-  }
-
-  async function sleepMs(ms: number): Promise<void> {
-    const remaining = deadline - Date.now();
-    const actual = Math.min(ms, Math.max(0, remaining));
-    if (actual <= 0) return;
-    return new Promise<void>((resolve) => {
-      const tid = setTimeout(resolve, actual);
-      if (externalSignal) {
-        const cleanup = () => {
-          clearTimeout(tid);
-          resolve();
-        };
-        externalSignal.addEventListener("abort", cleanup, { once: true });
-      }
-    });
-  }
-
-  let tabId: string | undefined;
-  let createdFreshTab = false;
-
-  try {
-    if (isAborted()) {
-      return miss("aborted-before-start", intentClass, t0);
-    }
-
-    // Ensure kuri is running
-    await kuri.start();
-    await kuri.discoverTabs();
-
-    if (isAborted()) {
-      return miss("aborted-after-start", intentClass, t0);
-    }
-
-    // Open a fresh tab (fall back to default)
-    try {
-      tabId = await kuri.newTab("about:blank");
-      createdFreshTab = !!tabId;
-      if (!tabId) tabId = await kuri.getDefaultTab();
-    } catch {
-      tabId = await kuri.getDefaultTab();
-    }
-
-    if (!tabId) {
-      return miss("no-tab", intentClass, t0);
-    }
-
-    if (isAborted()) {
-      await cleanupTab(tabId, createdFreshTab);
-      return miss("aborted-before-navigate", intentClass, t0);
-    }
-
-    // Start HAR recording before navigation to capture all requests
-    await kuri.harStart(tabId);
-
-    // Navigate to the target URL
-    await kuri.navigate(tabId, contextUrl);
-    await sleepMs(1_500);
-
-    if (isAborted()) {
-      await safeHarStop(tabId);
-      await cleanupTab(tabId, createdFreshTab);
-      return miss("aborted-after-navigate", intentClass, t0);
-    }
-
-    // Perform intent-driven action
-    let actionTaken = "navigate";
-    if (action.type === "search" && action.selector) {
-      const searchTerm =
-        typeof params.query === "string"
-          ? params.query
-          : typeof params.q === "string"
-            ? params.q
-            : intent;
-      try {
-        const searchResult = await kuri.evaluate(
-          tabId,
-          `(function(){
-            var sel = ${JSON.stringify(action.selector)};
-            var el = document.querySelector(sel);
-            if (!el) return 'not-found';
-            el.focus();
-            el.value = ${JSON.stringify(searchTerm)};
-            el.dispatchEvent(new Event('input', {bubbles:true}));
-            el.dispatchEvent(new Event('change', {bubbles:true}));
-            var form = el.closest('form');
-            if (form) { form.dispatchEvent(new Event('submit', {bubbles:true, cancelable:true})); return 'form-submit'; }
-            el.dispatchEvent(new KeyboardEvent('keydown', {key:'Enter',keyCode:13,bubbles:true}));
-            el.dispatchEvent(new KeyboardEvent('keypress', {key:'Enter',keyCode:13,bubbles:true}));
-            el.dispatchEvent(new KeyboardEvent('keyup', {key:'Enter',keyCode:13,bubbles:true}));
-            return 'search-enter';
-          })()`,
-        );
-        actionTaken =
-          typeof searchResult === "string" ? searchResult : "search-attempted";
-      } catch {
-        actionTaken = "search-failed";
-      }
-    } else if (action.type === "click" && action.selector) {
-      try {
-        const clickResult = await kuri.evaluate(
-          tabId,
-          `(function(){
-            var el = document.querySelector(${JSON.stringify(action.selector)});
-            if (!el) return 'not-found';
-            el.click();
-            return 'clicked';
-          })()`,
-        );
-        actionTaken =
-          typeof clickResult === "string" ? clickResult : "click-attempted";
-      } catch {
-        actionTaken = "click-failed";
-      }
-    }
-
-    // Wait for network activity to settle after the action
-    await sleepMs(2_000);
-
-    if (isAborted()) {
-      await safeHarStop(tabId);
-      await cleanupTab(tabId, createdFreshTab);
-      return miss(actionTaken, intentClass, t0);
-    }
-
-    // Stop HAR recording and collect entries
-    let harEntries: KuriHarEntry[] = [];
-    try {
-      const harResult = await kuri.harStop(tabId);
-      harEntries = harResult.entries ?? [];
-    } catch {
-      // non-fatal — HAR collection failed
-    }
-
-    // On hit: cleanup tab. On miss: keep tab alive for Phase 4 agentic loop.
-    if (filterJsonApiEntries(harEntries).length > 0) {
-      await cleanupTab(tabId, createdFreshTab);
-    }
-
-    // Filter to JSON API responses only
-    const jsonEntries = filterJsonApiEntries(harEntries);
-    const hit = jsonEntries.length > 0;
-
-    let result: unknown;
-    let miniSkill: SkillManifest | undefined;
-
-    if (hit) {
-      try {
-        const firstEntry = jsonEntries[0];
-        const text = firstEntry?.response.content?.text;
-        if (text) result = JSON.parse(text);
-      } catch {
-        result = undefined;
-      }
-      miniSkill = synthesizeSkillFromIntercepted(jsonEntries, domain, intent);
-    }
-
-    return {
-      hit,
-      result,
-      interceptedEntries: jsonEntries,
-      miniSkill,
-      actionTaken,
-      intentClass,
-      timeMs: Date.now() - t0,
-      tabId: hit ? undefined : tabId,  // keep tab alive on miss
-    };
-  } catch (err) {
-    // On any error, cleanup and return miss — never throw
-    if (tabId) {
-      try {
-        await safeHarStop(tabId);
-      } catch {
-        /* ignore */
-      }
-      try {
-        await cleanupTab(tabId, createdFreshTab);
-      } catch {
-        /* ignore */
-      }
-    }
-    const isAbortError =
-      err instanceof Error &&
-      (err.name === "AbortError" || err.name === "TimeoutError");
-    return {
-      hit: false,
-      interceptedEntries: [],
-      actionTaken: isAbortError ? "aborted" : "error",
-      intentClass,
-      timeMs: Date.now() - t0,
-    };
-  }
-}
-
-async function safeHarStop(tabId: string): Promise<void> {
-  try {
-    await kuri.harStop(tabId);
-  } catch {
-    /* best-effort */
-  }
-}
-
-async function cleanupTab(tabId: string, close: boolean): Promise<void> {
-  try {
-    if (close) {
-      await kuri.closeTab(tabId);
-    } else {
-      await kuri.navigate(tabId, "about:blank");
-    }
-  } catch {
-    /* best-effort */
-  }
-}

package/runtime-src/orchestrator/passive-publish.ts

@@ -1,152 +0,0 @@
-import { cachePublishedSkill, validateManifest, publishGraphEdges } from "../client/index.js";
-import { attributeLifecycle, type LifecycleEvent } from "../runtime/lifecycle.js";
-import { publishSkill } from "../marketplace/index.js";
-import type { SkillManifest } from "../types/index.js";
-
-type PassivePublishDeps = {
-  cachePublishedSkill: typeof cachePublishedSkill;
-  publishSkill: typeof publishSkill;
-  validateManifest: typeof validateManifest;
-};
-
-export type PassiveParityVerdict = "pass" | "fail" | "skip";
-
-type PassivePublishOptions = {
-  deps?: PassivePublishDeps;
-  parity?: PassiveParityVerdict | Promise<PassiveParityVerdict> | (() => Promise<PassiveParityVerdict>);
-};
-
-const defaultDeps: PassivePublishDeps = {
-  cachePublishedSkill,
-  publishSkill,
-  validateManifest,
-};
-
-const passivePublishInFlight = new Map<string, Promise<void>>();
-
-function mergeBackendDescriptions(
-  localSkill: SkillManifest,
-  publishedSkill: SkillManifest,
-): SkillManifest["endpoints"] {
-  return localSkill.endpoints.map((endpoint) => {
-    const backendEndpoint = publishedSkill.endpoints.find(
-      (candidate) =>
-        candidate.endpoint_id === endpoint.endpoint_id ||
-        (candidate.method === endpoint.method && candidate.url_template === endpoint.url_template),
-    );
-    if (!backendEndpoint?.description) return endpoint;
-    return {
-      ...endpoint,
-      description: backendEndpoint.description,
-    };
-  });
-}
-
-export function queuePassiveSkillPublish(
-  skill: SkillManifest,
-  options: PassivePublishOptions = {},
-): Promise<void> {
-  const deps = options.deps ?? defaultDeps;
-  const existing = passivePublishInFlight.get(skill.skill_id);
-  if (existing) return existing;
-
-  const job = (async () => {
-    if (skill.execution_type !== "http") return;
-
-    const parityVerdict =
-      typeof options.parity === "function"
-        ? await options.parity()
-        : options.parity instanceof Promise
-          ? await options.parity
-          : options.parity;
-    if (parityVerdict === "fail") {
-      console.warn(`[publish] passive publish skipped for ${skill.skill_id}: parity_failed`);
-      return;
-    }
-
-    const publishableEndpoints = skill.endpoints.filter((endpoint) => endpoint.method !== "WS");
-    if (publishableEndpoints.length === 0) return;
-
-    const { operation_graph: _graph, ...publishBase } = skill;
-    const publishDraft: SkillManifest = {
-      ...publishBase,
-      endpoints: publishableEndpoints,
-    };
-
-    const validation = await deps.validateManifest({ ...publishDraft, skill_id: "__validate__" });
-    if (!validation.valid) {
-      console.warn(
-        `[publish] passive publish skipped for ${skill.skill_id}: ${validation.hardErrors.join("; ") || "validation failed"}`,
-      );
-      return;
-    }
-
-    const publishStart = Date.now();
-    const published = await deps.publishSkill(publishDraft);
-    const publishMs = Date.now() - publishStart;
-    deps.cachePublishedSkill({
-      ...skill,
-      ...published,
-      endpoints: mergeBackendDescriptions(skill, published),
-      operation_graph: skill.operation_graph,
-      ...(skill.auth_profile_ref ? { auth_profile_ref: skill.auth_profile_ref } : {}),
-    });
-
-    // Publish graph edges via dedicated endpoint (fire-and-forget)
-    if (skill.operation_graph?.operations) {
-      for (const op of skill.operation_graph.operations) {
-        const opEdges = (skill.operation_graph.edges ?? [])
-          .filter(e => e.from_operation_id === op.operation_id)
-          .map(e => ({
-            target_endpoint_id: skill.operation_graph!.operations.find(
-              t => t.operation_id === e.to_operation_id
-            )?.endpoint_id ?? e.to_operation_id,
-            kind: e.kind,
-            confidence: e.confidence,
-          }));
-        if (opEdges.length > 0) {
-          publishGraphEdges(skill.domain, {
-            endpoint_id: op.endpoint_id,
-            method: op.method,
-            url_template: op.url_template,
-          }, opEdges).catch(() => {});
-        }
-      }
-    }
-
-    const publishEvent: LifecycleEvent = {
-      phase: "publish",
-      skill_id: skill.skill_id,
-      timestamp: new Date().toISOString(),
-      duration_ms: publishMs,
-      source: "marketplace",
-    };
-    const totals = attributeLifecycle([publishEvent]);
-    console.log(`[lifecycle] publish=${totals.get("publish")}ms for ${skill.skill_id}`);
-    console.log(`[publish] passive publish succeeded for ${skill.skill_id}`);
-  })()
-    .catch((err) => {
-      console.error(
-        `[publish] passive publish failed for ${skill.skill_id}: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    })
-    .finally(() => {
-      passivePublishInFlight.delete(skill.skill_id);
-    });
-
-  passivePublishInFlight.set(skill.skill_id, job);
-  return job;
-}
-
-/** Await all in-flight passive publish jobs. Call before process exit. */
-export async function drainPendingPassivePublishes(): Promise<void> {
-  const pending = [...passivePublishInFlight.values()];
-  if (pending.length === 0) return;
-  console.log(`[publish] draining ${pending.length} pending passive publish(es)...`);
-  await Promise.allSettled(pending);
-  console.log(`[publish] all passive publishes drained`);
-}
-
-export function resetPassivePublishQueueForTests(): void {
-  passivePublishInFlight.clear();
-}

package/runtime-src/orchestrator/timing-economics.ts

@@ -1,80 +0,0 @@
-import type { SkillManifest } from "../types/index.js";
-
-export const DEFAULT_CAPTURE_MS = 22_000;
-export const DEFAULT_CAPTURE_TOKENS = 30_000;
-export const CHARS_PER_TOKEN = 4;
-export const TOKEN_COST_PER_MILLION_USD = 3;
-export const TOKEN_COST_UC = Math.round(TOKEN_COST_PER_MILLION_USD);
-
-const SAVINGS_SOURCES = new Set([
-  "marketplace",
-  "route-cache",
-  "first-pass",
-  "direct-fetch",
-  "browser-action",
-]);
-
-export interface TimingEconomics {
-  response_bytes: number;
-  response_tokens: number;
-  tokens_saved: number;
-  tokens_saved_pct: number;
-  time_saved_pct: number;
-  baseline_total_ms?: number;
-  time_saved_ms?: number;
-  baseline_cost_uc?: number;
-  actual_cost_uc: number;
-  cost_saved_uc?: number;
-  baseline_source?: "real" | "estimated";
-}
-
-export function computeTimingEconomics({
-  source,
-  totalMs,
-  result,
-  skill,
-  paidSearchUc = 0,
-  paidExecutionUc = 0,
-}: {
-  source: string;
-  totalMs: number;
-  result: unknown;
-  skill?: Pick<SkillManifest, "discovery_cost">;
-  paidSearchUc?: number;
-  paidExecutionUc?: number;
-}): TimingEconomics {
-  const resultStr = typeof result === "string" ? result : JSON.stringify(result ?? "");
-  const responseBytes = resultStr.length;
-  const responseTokens = Math.ceil(responseBytes / CHARS_PER_TOKEN);
-  const actualCostUc = (responseTokens * TOKEN_COST_UC) + paidSearchUc + paidExecutionUc;
-
-  const economics: TimingEconomics = {
-    response_bytes: responseBytes,
-    response_tokens: responseTokens,
-    tokens_saved: 0,
-    tokens_saved_pct: 0,
-    time_saved_pct: 0,
-    actual_cost_uc: actualCostUc,
-  };
-
-  if (!SAVINGS_SOURCES.has(source)) return economics;
-
-  const baselineTokens = skill?.discovery_cost?.capture_tokens ?? DEFAULT_CAPTURE_TOKENS;
-  const baselineMs = skill?.discovery_cost?.capture_ms ?? DEFAULT_CAPTURE_MS;
-  const baselineCostUc = baselineTokens * TOKEN_COST_UC;
-
-  economics.tokens_saved = Math.max(0, baselineTokens - responseTokens);
-  economics.tokens_saved_pct = baselineTokens > 0
-    ? Math.round((economics.tokens_saved / baselineTokens) * 100)
-    : 0;
-  economics.time_saved_pct = baselineMs > 0
-    ? Math.round((Math.max(0, baselineMs - totalMs) / baselineMs) * 100)
-    : 0;
-  economics.baseline_total_ms = baselineMs;
-  economics.time_saved_ms = Math.max(0, baselineMs - totalMs);
-  economics.baseline_cost_uc = baselineCostUc;
-  economics.cost_saved_uc = Math.max(0, baselineCostUc - actualCostUc);
-  economics.baseline_source = skill?.discovery_cost ? "real" : "estimated";
-
-  return economics;
-}