robotrock 0.8.1 → 0.8.4

package/dist/trigger/index.js

@@ -2,12 +2,189 @@
 import { task, wait } from "@trigger.dev/sdk";
 
 // src/schemas/index.ts
+import { z as z2 } from "zod";
+
+// ../core/src/utils/safe-url.ts
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "metadata.google.internal",
+  "metadata.goog"
+]);
+function normalizeHostname(hostname) {
+  return hostname.toLowerCase().replace(/^\[|\]$/g, "");
+}
+function isBlockedIpv4(host) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!match) {
+    return false;
+  }
+  const octets = match.slice(1, 5).map((part) => Number(part));
+  if (octets.some((octet) => Number.isNaN(octet) || octet < 0 || octet > 255)) {
+    return true;
+  }
+  const [a, b, _c, _d] = octets;
+  if (a === void 0 || b === void 0) {
+    return true;
+  }
+  if (a === 127 || a === 0) return true;
+  if (a === 10) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+function ipv4FromNumericHost(host) {
+  if (/^\d+$/.test(host)) {
+    const num = Number(host);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  const hexMatch = /^0x([0-9a-f]{1,8})$/i.exec(host);
+  if (hexMatch) {
+    const num = Number.parseInt(hexMatch[1], 16);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  return null;
+}
+function isBlockedIpv4Mapped(host) {
+  const mappedDotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i.exec(host);
+  if (mappedDotted) {
+    return isBlockedIpv4(mappedDotted[1]);
+  }
+  const mappedHex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(host);
+  if (mappedHex) {
+    const high = Number.parseInt(mappedHex[1], 16);
+    const low = Number.parseInt(mappedHex[2], 16);
+    if (Number.isFinite(high) && Number.isFinite(low)) {
+      const a = high >> 8 & 255;
+      const b = high & 255;
+      const c = low >> 8 & 255;
+      const d = low & 255;
+      return isBlockedIpv4(`${a}.${b}.${c}.${d}`);
+    }
+  }
+  return false;
+}
+function isBlockedIpv6(host) {
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  if (host.startsWith("fc") || host.startsWith("fd")) {
+    return true;
+  }
+  if (host.startsWith("fe80:")) {
+    return true;
+  }
+  if (isBlockedIpv4Mapped(host)) {
+    return true;
+  }
+  return false;
+}
+function isBlockedHostname(hostname) {
+  const host = normalizeHostname(hostname);
+  if (!host) {
+    return true;
+  }
+  if (BLOCKED_HOSTNAMES.has(host)) {
+    return true;
+  }
+  if (host.endsWith(".localhost") || host.endsWith(".local")) {
+    return true;
+  }
+  const numericIpv4 = ipv4FromNumericHost(host);
+  if (numericIpv4 && isBlockedIpv4(numericIpv4)) {
+    return true;
+  }
+  return isBlockedIpv4(host) || isBlockedIpv6(host);
+}
+function isPublicHttpUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return false;
+  }
+  if (url.username || url.password) {
+    return false;
+  }
+  return !isBlockedHostname(url.hostname);
+}
+var PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+
+// ../core/src/schemas/task.ts
 import { z } from "zod";
-import {
-  isPublicHttpUrl,
-  PUBLIC_HTTP_URL_ERROR
-} from "@robotrock/core/utils";
-import { validateContextPublicUrls } from "@robotrock/core/schemas";
+
+// ../core/src/schemas/context-urls.ts
+function resolveLinkUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") ? value : `https://${value}`;
+}
+function widgetType(ui, field) {
+  const fieldUi = ui?.[field];
+  if (typeof fieldUi !== "object" || fieldUi === null) {
+    return void 0;
+  }
+  const widget = fieldUi["ui:widget"];
+  return typeof widget === "string" ? widget : void 0;
+}
+function validateUrlValue(value, widget) {
+  if (widget === "image" || widget === "link") {
+    if (typeof value !== "string") {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    const url = widget === "link" ? resolveLinkUrl(value) : value;
+    if (!isPublicHttpUrl(url)) {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    return null;
+  }
+  if (widget === "attachments" && Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item !== "object" || item === null) {
+        continue;
+      }
+      const url = item.url;
+      if (typeof url === "string" && !isPublicHttpUrl(resolveLinkUrl(url))) {
+        return PUBLIC_HTTP_URL_ERROR;
+      }
+    }
+  }
+  return null;
+}
+function validateContextPublicUrls(context) {
+  if (!context?.data) {
+    return null;
+  }
+  for (const [field, value] of Object.entries(context.data)) {
+    const widget = widgetType(context.ui, field);
+    if (!widget) {
+      continue;
+    }
+    const error = validateUrlValue(value, widget);
+    if (error) {
+      return `context.data.${field}: ${error}`;
+    }
+  }
+  return null;
+}
+
+// ../core/src/schemas/task.ts
 var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
   message: PUBLIC_HTTP_URL_ERROR
 });
@@ -35,6 +212,7 @@ var taskActionSchema = z.object({
   schema: jsonSchema7Schema.optional(),
   ui: uiSchemaSchema.optional(),
   data: z.record(z.string(), z.unknown()).optional(),
+  // Optional handlers for this action - if present, must have at least 1
   handlers: z.array(handlerSchema).min(1).optional()
 });
 var uiFieldSchemaSchema = z.object({
@@ -50,6 +228,7 @@ var contextDataSchema = z.object({
   ui: contextUiSchema
 }).optional();
 var taskContextObjectSchema = z.object({
+  /** Source application id; omitted tasks are grouped in the default inbox. */
   app: z.string().min(1).optional(),
   type: z.string().min(1),
   name: z.string().min(1),
@@ -114,17 +293,47 @@ var agentCostSchema = z.object({
   usd: z.number().nonnegative().optional()
 });
 var AGENT_INFO_MAX_KEYS = 32;
+var AGENT_TOOL_CALLS_MAX_KEYS = 64;
+var AGENT_OTEL_SPANS_MAX = 32;
+var agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
+var agentOtelSpanStatusSchema = z.enum(["ok", "error"]);
+var agentOtelSpanSummarySchema = z.object({
+  name: z.string().min(1),
+  durationMs: z.number().nonnegative(),
+  status: agentOtelSpanStatusSchema
+});
+var agentOtelSchema = z.object({
+  traceId: z.string().min(1),
+  spanId: z.string().min(1).optional(),
+  rootDurationMs: z.number().nonnegative().optional(),
+  spans: z.array(agentOtelSpanSummarySchema).max(AGENT_OTEL_SPANS_MAX).optional()
+});
 var agentTelemetrySchema = z.object({
+  /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
   version: z.string().min(1).optional(),
+  /** Total tool invocations. When omitted but `toolCalls` is set, the sum of counts is used. */
   toolCallCount: nonNegativeInt.optional(),
+  /** Per-tool invocation counts keyed by tool name. */
+  toolCalls: agentToolCallsSchema.optional(),
   cost: agentCostSchema.optional(),
-  info: z.record(z.string(), z.unknown()).optional()
+  /** Free-form metadata for experiments (model, prompt variant, etc.). */
+  info: z.record(z.string(), z.unknown()).optional(),
+  /** Structured OpenTelemetry span snapshot for feedback analysis. */
+  otel: agentOtelSchema.optional()
 }).refine(
   (data) => {
     const keys = data.info ? Object.keys(data.info) : [];
     return keys.length <= AGENT_INFO_MAX_KEYS;
   },
   { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS} keys` }
+).refine(
+  (data) => {
+    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
+    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS;
+  },
+  {
+    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS} tool names`
+  }
 );
 var createTaskBodySchema = taskContextObjectSchema.extend({
   assignTo: assignToSchema.optional(),
@@ -143,9 +352,174 @@ var createTaskBodySchema = taskContextObjectSchema.extend({
    * the inbox status bar and the thread update log.
    */
   update: threadUpdateInputSchema.optional(),
+  /** Agent telemetry (version, cost, tool calls) — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
 }).superRefine(refineContextPublicUrls);
-var threadUpdateBodySchema = threadUpdateInputSchema;
+
+// src/schemas/index.ts
+var safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
+  message: PUBLIC_HTTP_URL_ERROR
+});
+var jsonSchema7Schema2 = z2.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema2 = z2.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema2 = z2.object({
+  type: z2.literal("webhook"),
+  url: safeUrlSchema2,
+  headers: z2.record(z2.string(), z2.string())
+});
+var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
+  type: z2.literal("trigger"),
+  tokenId: z2.string().min(1)
+});
+var handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+var taskActionSchema2 = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  schema: jsonSchema7Schema2.optional(),
+  ui: uiSchemaSchema2.optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional(),
+  handlers: z2.array(handlerSchema2).min(1).optional()
+});
+var uiFieldSchemaSchema2 = z2.object({
+  "ui:widget": z2.string().optional(),
+  "ui:title": z2.string().optional(),
+  "ui:description": z2.string().optional(),
+  "ui:options": z2.record(z2.string(), z2.unknown()).optional(),
+  items: z2.lazy(() => z2.record(z2.string(), uiFieldSchemaSchema2)).optional()
+}).passthrough();
+var contextUiSchema2 = z2.record(z2.string(), uiFieldSchemaSchema2).optional();
+var contextDataSchema2 = z2.object({
+  data: z2.record(z2.string(), z2.unknown()),
+  ui: contextUiSchema2
+}).optional();
+var taskContextObjectSchema2 = z2.object({
+  app: z2.string().min(1).optional(),
+  type: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string().optional(),
+  validUntil: z2.string().optional(),
+  context: contextDataSchema2,
+  version: z2.literal(2).optional(),
+  actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
+});
+function refineContextPublicUrls2(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema2 = taskContextObjectSchema2.superRefine(
+  refineContextPublicUrls2
+);
+var assignToSchema2 = z2.object({
+  users: z2.array(z2.string().email()).optional(),
+  groups: z2.array(z2.string().min(1)).optional()
+}).refine(
+  (data) => {
+    const groups = data.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var threadUpdateMessageSchema2 = z2.string().min(1).max(500);
+var threadUpdateStatuses2 = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema2 = z2.enum(threadUpdateStatuses2);
+var threadUpdateInputSchema2 = z2.object({
+  message: threadUpdateMessageSchema2,
+  status: threadUpdateStatusSchema2.optional()
+});
+var taskPriorities2 = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema2 = z2.enum(taskPriorities2);
+var nonNegativeInt2 = z2.number().int().nonnegative();
+var agentCostTokensSchema2 = z2.object({
+  input: nonNegativeInt2.optional(),
+  output: nonNegativeInt2.optional(),
+  total: nonNegativeInt2.optional()
+});
+var agentCostSchema2 = z2.object({
+  tokens: agentCostTokensSchema2.optional(),
+  eur: z2.number().nonnegative().optional(),
+  usd: z2.number().nonnegative().optional()
+});
+var AGENT_INFO_MAX_KEYS2 = 32;
+var AGENT_TOOL_CALLS_MAX_KEYS2 = 64;
+var AGENT_OTEL_SPANS_MAX2 = 32;
+var agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
+var agentOtelSpanStatusSchema2 = z2.enum(["ok", "error"]);
+var agentOtelSpanSummarySchema2 = z2.object({
+  name: z2.string().min(1),
+  durationMs: z2.number().nonnegative(),
+  status: agentOtelSpanStatusSchema2
+});
+var agentOtelSchema2 = z2.object({
+  traceId: z2.string().min(1),
+  spanId: z2.string().min(1).optional(),
+  rootDurationMs: z2.number().nonnegative().optional(),
+  spans: z2.array(agentOtelSpanSummarySchema2).max(AGENT_OTEL_SPANS_MAX2).optional()
+});
+var agentTelemetrySchema2 = z2.object({
+  version: z2.string().min(1).optional(),
+  toolCallCount: nonNegativeInt2.optional(),
+  toolCalls: agentToolCallsSchema2.optional(),
+  cost: agentCostSchema2.optional(),
+  info: z2.record(z2.string(), z2.unknown()).optional(),
+  otel: agentOtelSchema2.optional()
+}).refine(
+  (data) => {
+    const keys = data.info ? Object.keys(data.info) : [];
+    return keys.length <= AGENT_INFO_MAX_KEYS2;
+  },
+  { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS2} keys` }
+).refine(
+  (data) => {
+    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
+    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS2;
+  },
+  {
+    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS2} tool names`
+  }
+);
+var createTaskBodySchema2 = taskContextObjectSchema2.extend({
+  assignTo: assignToSchema2.optional(),
+  /**
+   * Groups related tasks together. When omitted, the server generates one and
+   * returns it so the caller can reuse it on later tasks in the same thread.
+   */
+  threadId: z2.string().min(1).optional(),
+  /**
+   * Optional thread priority. When set, applies to the whole thread and
+   * overwrites any previous priority. Omit on later tasks to leave unchanged.
+   */
+  priority: taskPrioritySchema2.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema2.optional(),
+  agent: agentTelemetrySchema2.optional()
+}).superRefine(refineContextPublicUrls2);
+var threadUpdateBodySchema = threadUpdateInputSchema2;
 
 // src/approval-result.ts
 var TaskTimeoutError = class extends Error {
@@ -259,7 +633,7 @@ var RobotRock = class {
       ...task2.update !== void 0 ? { update: task2.update } : {},
       ...task2.agent !== void 0 ? { agent: task2.agent } : {}
     };
-    const validation = createTaskBodySchema.safeParse(bodyPayload);
+    const validation = createTaskBodySchema2.safeParse(bodyPayload);
     if (!validation.success) {
       throw new RobotRockError(
         `Invalid task: ${validation.error.issues[0]?.message}`,