unbrowse 3.1.0 → 3.2.0

package/runtime-src/workflow/publish.ts

@@ -1,225 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { log } from "../logger.js";
-import { sanitizeForPublish } from "../publish/sanitize.js";
-import type {
-  EndpointDescriptor,
-  SkillManifest,
-  WorkflowArtifact,
-  WorkflowPublishArtifact,
-  WorkflowPublishRecipe,
-  WorkflowPublishStatus,
-} from "../types/index.js";
-
-function sanitizeProfileName(value: string): string {
-  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-
-function getConfigDir(): string {
-  if (process.env.UNBROWSE_CONFIG_DIR) return process.env.UNBROWSE_CONFIG_DIR;
-  const profile = sanitizeProfileName(process.env.UNBROWSE_PROFILE ?? "");
-  return profile
-    ? join(homedir(), ".unbrowse", "profiles", profile)
-    : join(homedir(), ".unbrowse");
-}
-
-function getWorkflowExportDir(): string {
-  return process.env.UNBROWSE_WORKFLOW_EXPORT_DIR
-    ?? join(getConfigDir(), "workflow-exports");
-}
-
-export function workflowPublishArtifactPathForSkill(skillId: string): string {
-  return join(getWorkflowExportDir(), `${skillId}.json`);
-}
-
-export function readWorkflowPublishArtifact(skillId: string): WorkflowPublishArtifact | null {
-  const target = workflowPublishArtifactPathForSkill(skillId);
-  if (!existsSync(target)) return null;
-  try {
-    return JSON.parse(readFileSync(target, "utf-8")) as WorkflowPublishArtifact;
-  } catch {
-    return null;
-  }
-}
-
-export function listWorkflowPublishArtifacts(): string[] {
-  const dir = getWorkflowExportDir();
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((entry) => entry.endsWith(".json"))
-    .map((entry) => join(dir, entry));
-}
-
-function stripQuery(url?: string): string | undefined {
-  if (!url) return undefined;
-  try {
-    const parsed = new URL(url);
-    return `${parsed.origin}${parsed.pathname}`;
-  } catch {
-    return url;
-  }
-}
-
-function docBullets(
-  skill: SkillManifest,
-  endpoints: EndpointDescriptor[],
-  workflowArtifact: WorkflowArtifact | null,
-  rootEndpointIds: string[],
-): string[] {
-  const bullets = [
-    `${endpoints.length} publishable endpoint${endpoints.length === 1 ? "" : "s"} for ${skill.intent_signature}`,
-  ];
-  if (rootEndpointIds.length > 0) {
-    const closureAdded = Math.max(0, endpoints.length - rootEndpointIds.length);
-    bullets.push(
-      closureAdded > 0
-        ? `publish closure: ${rootEndpointIds.length} root step${rootEndpointIds.length === 1 ? "" : "s"} + ${closureAdded} DAG-linked dependent step${closureAdded === 1 ? "" : "s"}`
-        : `publish closure: ${rootEndpointIds.length} root step${rootEndpointIds.length === 1 ? "" : "s"}`,
-    );
-  }
-  if (workflowArtifact) {
-    bullets.push(`${workflowArtifact.recipes.length} workflow recipe${workflowArtifact.recipes.length === 1 ? "" : "s"} captured`);
-    const preferred = workflowArtifact.recipes.filter((recipe) => recipe.preferred).map((recipe) => recipe.endpoint_id);
-    if (preferred.length > 0) bullets.push(`preferred routes: ${preferred.join(", ")}`);
-    const guarded = workflowArtifact.recipes.filter((recipe) => recipe.mutation_guard.confirm_unsafe_required).length;
-    if (guarded > 0) bullets.push(`${guarded} mutation recipe${guarded === 1 ? "" : "s"} require confirm_unsafe`);
-    const preferredRecipe = workflowArtifact.recipes.find((recipe) => recipe.preferred) ?? workflowArtifact.recipes[0];
-    const preferredUsage = preferredRecipe ? usageNotesForRecipe(preferredRecipe)[0] : undefined;
-    if (preferredUsage) bullets.push(preferredUsage);
-  } else {
-    bullets.push("no workflow artifact captured yet");
-  }
-  return bullets;
-}
-
-function usageNotesForRecipe(recipe: WorkflowArtifact["recipes"][number]): string[] {
-  const notes: string[] = [];
-  const requiredUserParams = recipe.replay_contract.parameter_specs
-    .filter((param) => param.user_supplied && param.required)
-    .map((param) => `${param.name}:${param.type}${param.enum_values?.length ? `=${param.enum_values.join("|")}` : ""}`);
-  if (requiredUserParams.length > 0) {
-    notes.push(`params: ${requiredUserParams.join(", ")}`);
-  }
-  const derivedParams = recipe.replay_contract.parameter_specs
-    .filter((param) => !param.user_supplied)
-    .map((param) => `${param.name}<=${param.derived_from?.[0] ?? "observed state"}`);
-  if (derivedParams.length > 0) {
-    notes.push(`derived: ${derivedParams.slice(0, 4).join(", ")}`);
-  }
-  const prereqs = recipe.replay_contract.prerequisite_specs
-    .filter((entry) => entry.required)
-    .map((entry) => entry.name);
-  if (prereqs.length > 0) {
-    notes.push(`prereqs: ${prereqs.slice(0, 4).join(", ")}`);
-  }
-  const payment = recipe.replay_contract.payment_requirement;
-  if (payment.status === "x402_required") {
-    notes.push(`payment: x402 ${payment.price_usd ?? "dynamic"} ${payment.currency ?? "USDC"}`);
-  } else if (payment.status === "x402_optional") {
-    notes.push("payment: x402 may apply when marketplace pricing is configured");
-  } else {
-    notes.push("payment: free");
-  }
-  notes.push("replay: explicit only; traversal stays browser-native");
-  return notes;
-}
-
-function buildPublishedRecipes(workflowArtifact: WorkflowArtifact | null): WorkflowPublishRecipe[] {
-  if (!workflowArtifact) return [];
-  return workflowArtifact.recipes.map((recipe) => ({
-    endpoint_id: recipe.endpoint_id,
-    operation_id: recipe.operation_id,
-    preferred: recipe.preferred,
-    provenance_backed: recipe.provenance_backed,
-    last_successful_strategy: recipe.last_successful_strategy,
-    steps: recipe.steps.map((step) => ({
-      strategy: step.strategy,
-      provenance: step.provenance,
-      trigger_url: stripQuery(step.trigger_url),
-      action_count: step.action_sequence?.length ?? 0,
-    })),
-    mutation_guard: recipe.mutation_guard,
-    token_bindings: recipe.token_bindings.map((binding) => ({
-      target_location: binding.target_location,
-      target_name: binding.target_name,
-      refresh_on_statuses: binding.refresh_on_statuses,
-      selected_source_kind: binding.selected_source_kind,
-      selected_source_name: binding.selected_source_name,
-      candidates: binding.candidates.map((candidate) => ({
-        source_kind: candidate.source_kind,
-        source_name: candidate.source_name,
-        source_path: candidate.source_path,
-        confidence: candidate.confidence,
-        })),
-    })),
-    replay_contract: recipe.replay_contract,
-    usage_notes: usageNotesForRecipe(recipe),
-  }));
-}
-
-export function buildWorkflowPublishArtifact(
-  skill: SkillManifest,
-  workflowArtifact: WorkflowArtifact | null,
-  options?: {
-    publishStatus?: WorkflowPublishStatus;
-    publishedAt?: string;
-    validationErrors?: string[];
-    endpointIds?: string[];
-    rootEndpointIds?: string[];
-  },
-): WorkflowPublishArtifact {
-  const includeEndpointIds = new Set(options?.endpointIds ?? skill.endpoints.map((endpoint) => endpoint.endpoint_id));
-  const rootEndpointIds = (options?.rootEndpointIds ?? []).filter((endpointId) => includeEndpointIds.has(endpointId));
-  const includedEndpoints = skill.endpoints.filter((endpoint) => includeEndpointIds.has(endpoint.endpoint_id));
-  const sanitizedEndpoints = sanitizeForPublish(includedEndpoints.filter((endpoint) => endpoint.method !== "WS"));
-  const recipes = buildPublishedRecipes(workflowArtifact).filter((recipe) => includeEndpointIds.has(recipe.endpoint_id));
-  const tokenBindingCount = recipes.reduce((sum, recipe) => sum + recipe.token_bindings.length, 0);
-  const closureAddedCount = rootEndpointIds.length > 0
-    ? Math.max(0, sanitizedEndpoints.length - rootEndpointIds.length)
-    : 0;
-  return {
-    export_version: "1",
-    generated_at: new Date().toISOString(),
-    publish_status: options?.publishStatus ?? "captured",
-    ...(options?.publishedAt ? { published_at: options.publishedAt } : {}),
-    ...(options?.validationErrors?.length ? { validation_errors: options.validationErrors } : {}),
-    skill_id: skill.skill_id,
-    domain: skill.domain,
-    intent_signature: skill.intent_signature,
-    sanitized_endpoints: sanitizedEndpoints,
-    workflow_summary: {
-      recipe_count: recipes.length,
-      preferred_endpoint_ids: recipes.filter((recipe) => recipe.preferred).map((recipe) => recipe.endpoint_id),
-      authenticated_capture: workflowArtifact?.auth_state.authenticated ?? false,
-      token_binding_count: tokenBindingCount,
-      trigger_url_count: workflowArtifact?.evidence.trigger_urls.length ?? 0,
-      included_endpoint_count: sanitizedEndpoints.length,
-      root_endpoint_ids: rootEndpointIds,
-      closure_added_count: closureAddedCount,
-    },
-    auth_summary: workflowArtifact?.auth_state ?? {
-      cookie_names: [],
-      header_names: [],
-      authenticated: false,
-    },
-    recipes,
-    docs: {
-      headline: `${skill.domain} workflow export`,
-      bullets: docBullets(skill, sanitizedEndpoints, workflowArtifact, rootEndpointIds),
-    },
-  };
-}
-
-export function writeWorkflowPublishArtifact(artifact: WorkflowPublishArtifact): string | undefined {
-  try {
-    const dir = getWorkflowExportDir();
-    mkdirSync(dir, { recursive: true });
-    const target = workflowPublishArtifactPathForSkill(artifact.skill_id);
-    writeFileSync(target, JSON.stringify(artifact, null, 2), "utf-8");
-    return target;
-  } catch (error) {
-    log("workflow", `publish export write failed for ${artifact.skill_id}: ${error instanceof Error ? error.message : String(error)}`);
-    return undefined;
-  }
-}

package/runtime-src/workflow/runtime.ts

@@ -1,213 +0,0 @@
-import type {
-  TokenBinding,
-  WorkflowArtifact,
-  WorkflowParameterSpec,
-  WorkflowRecipe,
-  WorkflowStep,
-  WorkflowStepStrategy,
-} from "../types/index.js";
-
-export interface WorkflowRuntimeContext {
-  cookies: Array<{ name: string; value: string; domain: string }>;
-  authHeaders: Record<string, string>;
-  body?: unknown;
-  artifact: WorkflowArtifact;
-}
-
-export interface ResolvedWorkflowBindings {
-  extraHeaders: Record<string, string>;
-  bodyOverride?: unknown;
-  selectedBindings: Array<{ target_name: string; source_kind: string; source_name: string }>;
-}
-
-export interface WorkflowParamValidationError {
-  name: string;
-  reason: string;
-  allowed_values?: Array<string | number | boolean>;
-}
-
-function cloneBody(body: unknown): unknown {
-  if (!body || typeof body !== "object") return body;
-  if (Array.isArray(body)) return body.map((entry) => cloneBody(entry));
-  return { ...(body as Record<string, unknown>) };
-}
-
-function resolveBindingValue(
-  binding: TokenBinding,
-  context: WorkflowRuntimeContext,
-): { value?: string; source_kind?: string; source_name?: string } {
-  for (const candidate of binding.candidates) {
-    if (candidate.source_kind === "cookie") {
-      const cookie = context.cookies.find((entry) => entry.name.toLowerCase() === candidate.source_name.toLowerCase());
-      if (cookie?.value != null) return { value: cookie.value, source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-    if (candidate.source_kind === "request_header" || candidate.source_kind === "response_header") {
-      const header = Object.entries(context.authHeaders).find(([key]) => key.toLowerCase() === candidate.source_name.toLowerCase());
-      if (header?.[1] != null) return { value: header[1], source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-    if (candidate.source_kind === "hidden_input") {
-      const hint = context.artifact.evidence.dom_form_hints.find((entry) => entry.field_name.toLowerCase() === candidate.source_name.toLowerCase());
-      if (hint?.value != null) return { value: hint.value, source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-    if (candidate.source_kind === "meta") {
-      const hint = context.artifact.evidence.meta_hints.find((entry) => entry.key.toLowerCase() === candidate.source_name.toLowerCase());
-      if (hint?.value != null) return { value: hint.value, source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-    if (candidate.source_kind === "bootstrap_json") {
-      const hint = context.artifact.evidence.bootstrap_hints.find((entry) => entry.path === candidate.source_path || entry.path.toLowerCase().endsWith(candidate.source_name.toLowerCase()));
-      if (hint?.value != null) return { value: hint.value, source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-    if (candidate.source_kind === "request_body" && candidate.observed_value != null) {
-      return { value: candidate.observed_value, source_kind: candidate.source_kind, source_name: candidate.source_name };
-    }
-  }
-  return {};
-}
-
-export function resolveWorkflowBindings(
-  recipe: WorkflowRecipe,
-  context: WorkflowRuntimeContext,
-): ResolvedWorkflowBindings {
-  const extraHeaders: Record<string, string> = {};
-  let bodyOverride = cloneBody(context.body);
-  const selectedBindings: ResolvedWorkflowBindings["selectedBindings"] = [];
-
-  for (const binding of recipe.token_bindings) {
-    const resolved = resolveBindingValue(binding, context);
-    if (resolved.value == null || !resolved.source_kind || !resolved.source_name) continue;
-    selectedBindings.push({
-      target_name: binding.target_name,
-      source_kind: resolved.source_kind,
-      source_name: resolved.source_name,
-    });
-    if (binding.target_location === "header") {
-      extraHeaders[binding.target_name.toLowerCase()] = resolved.value;
-      continue;
-    }
-    if (!bodyOverride || typeof bodyOverride !== "object" || Array.isArray(bodyOverride)) {
-      bodyOverride = {};
-    }
-    (bodyOverride as Record<string, unknown>)[binding.target_name] = resolved.value;
-  }
-
-  return { extraHeaders, bodyOverride, selectedBindings };
-}
-
-function valueForSpec(
-  spec: WorkflowParameterSpec,
-  params: Record<string, unknown>,
-): unknown {
-  const value = params[spec.name];
-  return value === undefined ? spec.default_value : value;
-}
-
-function matchesSpecType(spec: WorkflowParameterSpec, value: unknown): boolean {
-  if (value == null) return true;
-  switch (spec.type) {
-    case "boolean":
-      return typeof value === "boolean" || value === "true" || value === "false";
-    case "integer":
-      return typeof value === "number"
-        ? Number.isInteger(value)
-        : typeof value === "string" && /^-?\d+$/.test(value);
-    case "number":
-      return typeof value === "number"
-        ? Number.isFinite(value)
-        : typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value);
-    case "array":
-      return Array.isArray(value);
-    case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value);
-    case "string":
-    default:
-      return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-}
-
-function matchesSpecFormat(spec: WorkflowParameterSpec, value: unknown): boolean {
-  if (value == null || spec.format == null) return true;
-  const sample = String(value);
-  switch (spec.format) {
-    case "date":
-      return /^\d{4}-\d{2}-\d{2}$/.test(sample);
-    case "url":
-      return /^https?:\/\//i.test(sample);
-    case "email":
-      return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(sample);
-    default:
-      return true;
-  }
-}
-
-export function validateWorkflowReplayParams(
-  recipe: WorkflowRecipe,
-  params: Record<string, unknown>,
-): WorkflowParamValidationError[] {
-  const errors: WorkflowParamValidationError[] = [];
-  for (const spec of recipe.replay_contract.parameter_specs) {
-    if (!spec.user_supplied) continue;
-    const value = valueForSpec(spec, params);
-    if (spec.required && (value == null || value === "")) {
-      errors.push({ name: spec.name, reason: "required" });
-      continue;
-    }
-    if (value == null || value === "") continue;
-    if (spec.enum_values?.length && !spec.enum_values.some((candidate) => String(candidate) === String(value))) {
-      errors.push({
-        name: spec.name,
-        reason: "invalid_enum",
-        allowed_values: spec.enum_values,
-      });
-      continue;
-    }
-    if (!matchesSpecType(spec, value)) {
-      errors.push({ name: spec.name, reason: `expected_${spec.type}` });
-      continue;
-    }
-    if (!matchesSpecFormat(spec, value)) {
-      errors.push({ name: spec.name, reason: `expected_format_${spec.format}` });
-    }
-  }
-  return errors;
-}
-
-export function needsWorkflowTokenRefresh(status: number): boolean {
-  return status === 401 || status === 403 || status === 419 || status === 422;
-}
-
-export function pickWorkflowRecipe(
-  artifact: WorkflowArtifact | null,
-  endpointId: string,
-): WorkflowRecipe | null {
-  if (!artifact) return null;
-  const exact = artifact.recipes.find((recipe) => recipe.endpoint_id === endpointId);
-  if (!exact) return null;
-  const preferredStrategy = exact.last_successful_strategy;
-  const steps = preferredStrategy
-    ? [...exact.steps].sort((lhs, rhs) => {
-        if (lhs.strategy === preferredStrategy) return -1;
-        if (rhs.strategy === preferredStrategy) return 1;
-        return 0;
-      })
-    : exact.steps;
-  return { ...exact, steps };
-}
-
-export function translateWorkflowStrategy(
-  strategy: WorkflowStepStrategy,
-): "server" | "trigger-intercept" | "browser" {
-  switch (strategy) {
-    case "server":
-      return "server";
-    case "trigger-intercept":
-      return "trigger-intercept";
-    case "browser-action":
-    case "browser-fetch":
-    default:
-      return "browser";
-  }
-}
-
-export function strategyLabel(step: WorkflowStep): string {
-  return step.strategy;
-}