ummaya 0.2.4 → 0.2.5

package/tui/src/tools/WebFetchTool/resolvedAddressSafety.ts

@@ -0,0 +1,78 @@
+import { lookup } from 'node:dns/promises'
+import { isIP } from 'node:net'
+import {
+  validatePublicWebFetchUrl,
+  type WebFetchUrlSafetyResult,
+} from './urlSafety.js'
+
+type ResolvedAddress = {
+  readonly address: string
+  readonly family: 4 | 6
+}
+
+type LookupHost = (hostname: string) => Promise<readonly ResolvedAddress[]>
+
+const lookupHost: LookupHost = async hostname => {
+  const addresses = await lookup(hostname, { all: true, verbatim: true })
+  return addresses.flatMap(({ address, family }) =>
+    family === 4 || family === 6 ? [{ address, family }] : [],
+  )
+}
+
+export async function validateResolvedPublicWebFetchUrl(
+  value: string,
+  resolveHost: LookupHost = lookupHost,
+): Promise<WebFetchUrlSafetyResult> {
+  const validation = validatePublicWebFetchUrl(value)
+  if (!validation.ok || isIP(validation.hostname) !== 0) {
+    return validation
+  }
+
+  let addresses: readonly ResolvedAddress[]
+  try {
+    addresses = await resolveHost(validation.hostname)
+  } catch (error) {
+    if (error instanceof Error) {
+      return unsafeResolvedUrl(
+        `WebFetch could not resolve ${validation.hostname} to a public address.`,
+      )
+    }
+    return unsafeResolvedUrl(
+      `WebFetch could not safely classify ${validation.hostname}.`,
+    )
+  }
+
+  if (addresses.length === 0) {
+    return unsafeResolvedUrl(
+      `WebFetch could not safely classify ${validation.hostname}.`,
+    )
+  }
+
+  for (const resolved of addresses) {
+    const resolvedValidation = validatePublicWebFetchUrl(
+      addressUrlForSafetyCheck(resolved),
+    )
+    if (!resolvedValidation.ok) {
+      return unsafeResolvedUrl(
+        `WebFetch cannot access ${validation.hostname} because it resolved to a private, loopback, metadata, or link-local address (${resolved.address}).`,
+      )
+    }
+  }
+
+  return validation
+}
+
+function addressUrlForSafetyCheck({
+  address,
+  family,
+}: ResolvedAddress): string {
+  return family === 6 ? `http://[${address}]/` : `http://${address}/`
+}
+
+function unsafeResolvedUrl(message: string): WebFetchUrlSafetyResult {
+  return {
+    ok: false,
+    reason: 'unsafe_url',
+    message,
+  }
+}

package/tui/src/tools/WebFetchTool/sourceVerification.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod/v4'
+import { validatePublicWebFetchUrl } from './urlSafety.js'
+
+export const SOURCE_VERIFICATION_POLICY =
+  'source_results_untrusted_until_user_approval' as const
+
+export const sourceVerificationEvidenceSchema = z.object({
+  toolId: z.string(),
+  sourceUrl: z.string().nullable(),
+  title: z.string().nullable(),
+  observedAt: z.string(),
+  citationHandle: z.string(),
+  blockedOrUsed: z.enum(['blocked', 'needs_input']),
+  trust: z.literal('untrusted_source'),
+  promptInjection: z.enum(['detected', 'not_detected']),
+  redacted: z.boolean(),
+})
+
+export const sourceVerificationSchema = z.object({
+  mutationAllowed: z.literal(false),
+  userApprovalRequired: z.literal(true),
+  secretEgress: z.literal(false),
+  policy: z.literal(SOURCE_VERIFICATION_POLICY).default(SOURCE_VERIFICATION_POLICY),
+  evidence: z.array(sourceVerificationEvidenceSchema),
+})
+
+export type SourceVerificationEvidence = z.infer<
+  typeof sourceVerificationEvidenceSchema
+>
+export type SourceVerification = z.infer<typeof sourceVerificationSchema>
+
+const SECRET_TEXT_PATTERNS: readonly RegExp[] = [
+  /Authorization\s*:\s*[^\n\r]+/gi,
+  /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+  /Cookie\s*:\s*[^\n\r]+/gi,
+  /\b[A-Z0-9_]*(?:API|AUTH|ACCESS|REFRESH|SESSION)[_-]?KEY\s*=\s*[^\s&]+/gi,
+  /\b(?:session|access|refresh|id)[_-]?token\s*=\s*[^\s&]+/gi,
+  /\bsk-[A-Za-z0-9_-]{8,}\b/g,
+]
+
+const SECRET_QUERY_KEYS = new Set([
+  'access_token',
+  'api_key',
+  'apikey',
+  'auth',
+  'authorization',
+  'cookie',
+  'id_token',
+  'key',
+  'refresh_token',
+  'servicekey',
+  'session',
+  'session_token',
+  'token',
+])
+
+const PROMPT_INJECTION_PATTERNS: readonly RegExp[] = [
+  /ignore\s+(?:all\s+)?previous\s+instructions/i,
+  /change\s+(?:the\s+)?permission\s+policy/i,
+  /bypass\s+(?:permissions?|approval|policy)/i,
+  /system\s+prompt/i,
+  /treat\s+this\s+as\s+(?:a\s+)?system\s+instruction/i,
+]
+
+function stableHandlePart(value: string): string {
+  const lowered = value.toLowerCase().replace(/[^a-z0-9]+/g, '-')
+  const trimmed = lowered.replace(/^-+|-+$/g, '')
+  return trimmed.length > 0 ? trimmed.slice(0, 48) : 'source'
+}
+
+function hasRedactionCandidate(value: string): boolean {
+  return SECRET_TEXT_PATTERNS.some(pattern => {
+    pattern.lastIndex = 0
+    return pattern.test(value)
+  })
+}
+
+export function redactSourceVerificationText(value: string): string {
+  const redacted = SECRET_TEXT_PATTERNS.reduce(
+    (current, pattern) => current.replace(pattern, '[REDACTED]'),
+    value,
+  )
+  return redacted
+    .replaceAll('<source_verification>', '[source_verification]')
+    .replaceAll('</source_verification>', '[/source_verification]')
+}
+
+export function redactSourceVerificationUrl(value: string | null): string | null {
+  if (value === null) return null
+  const validation = validatePublicWebFetchUrl(value)
+  if (!validation.ok) return null
+  const { parsedUrl } = validation
+  for (const key of [...parsedUrl.searchParams.keys()]) {
+    if (SECRET_QUERY_KEYS.has(key.toLowerCase())) {
+      parsedUrl.searchParams.set(key, '[REDACTED]')
+    }
+  }
+  return redactSourceVerificationText(parsedUrl.toString())
+}
+
+export function detectPromptInjection(value: string): 'detected' | 'not_detected' {
+  return PROMPT_INJECTION_PATTERNS.some(pattern => pattern.test(value))
+    ? 'detected'
+    : 'not_detected'
+}
+
+export function buildSourceEvidence({
+  toolId,
+  sourceUrl,
+  title,
+  observedAt = new Date().toISOString(),
+  blockedOrUsed,
+  rawText,
+}: {
+  toolId: string
+  sourceUrl: string | null
+  title: string | null
+  observedAt?: string
+  blockedOrUsed: SourceVerificationEvidence['blockedOrUsed']
+  rawText: string
+}): SourceVerificationEvidence {
+  const redactedUrl = redactSourceVerificationUrl(sourceUrl)
+  const redactedTitle = title === null ? null : redactSourceVerificationText(title)
+  const combined = `${rawText}\n${redactedTitle ?? ''}\n${redactedUrl ?? ''}`
+  return {
+    toolId,
+    sourceUrl: redactedUrl,
+    title: redactedTitle,
+    observedAt,
+    citationHandle: `src-${stableHandlePart(toolId)}-${stableHandlePart(
+      redactedUrl ?? redactedTitle ?? rawText,
+    )}`,
+    blockedOrUsed,
+    trust: 'untrusted_source',
+    promptInjection: detectPromptInjection(combined),
+    redacted:
+      hasRedactionCandidate(rawText) ||
+      (sourceUrl !== null && redactSourceVerificationUrl(sourceUrl) !== sourceUrl) ||
+      (title !== null && redactSourceVerificationText(title) !== title),
+  }
+}
+
+export function buildSourceVerification(
+  evidence: readonly SourceVerificationEvidence[],
+): SourceVerification {
+  return {
+    mutationAllowed: false,
+    userApprovalRequired: true,
+    secretEgress: false,
+    policy: SOURCE_VERIFICATION_POLICY,
+    evidence: [...evidence],
+  }
+}
+
+export function formatSourceVerificationForModel(
+  sourceVerification: SourceVerification | undefined,
+): string {
+  if (sourceVerification === undefined) return ''
+  const parsed = sourceVerificationSchema.safeParse(sourceVerification)
+  if (!parsed.success) return ''
+
+  const lines = [
+    '<source_verification>',
+    `policy: ${parsed.data.policy}`,
+    `document_mutation_allowed: ${parsed.data.mutationAllowed}`,
+    `user_approval_required: ${parsed.data.userApprovalRequired}`,
+    `permission_policy_mutation_allowed: false`,
+    `no_secret_egress: ${!parsed.data.secretEgress}`,
+    `no_fabricated_fact: true`,
+  ]
+
+  for (const evidence of parsed.data.evidence) {
+    const safeSourceUrl = redactSourceVerificationUrl(evidence.sourceUrl)
+    const safeTitle =
+      evidence.title === null ? null : redactSourceVerificationText(evidence.title)
+    lines.push(
+      `tool_id: ${redactSourceVerificationText(evidence.toolId)}`,
+      `source_url: ${safeSourceUrl ?? 'none'}`,
+      `title: ${safeTitle ?? 'none'}`,
+      `timestamp: ${evidence.observedAt}`,
+      `citation_handle: ${redactSourceVerificationText(evidence.citationHandle)}`,
+      `blocked_or_used: ${evidence.blockedOrUsed}`,
+      `trust: ${evidence.trust}`,
+      `prompt_injection: ${evidence.promptInjection}`,
+      `redacted: ${evidence.redacted}`,
+    )
+  }
+
+  lines.push('</source_verification>')
+  return lines.join('\n')
+}
+
+export function formatSourceVerifiedToolResult({
+  result,
+  sourceVerification,
+}: {
+  result: string
+  sourceVerification?: SourceVerification
+}): string {
+  const safeResult = redactSourceVerificationText(result)
+  const verification = formatSourceVerificationForModel(sourceVerification)
+  if (!verification) return safeResult
+  return `${safeResult}\n\n${verification}`
+}

package/tui/src/tools/WebFetchTool/types.ts

@@ -0,0 +1,23 @@
+import type { SourceVerification } from './sourceVerification.js'
+
+export type WebFetchOutput = {
+  readonly bytes: number
+  readonly code: number
+  readonly codeText: string
+  readonly result: string
+  readonly durationMs: number
+  readonly url: string
+  readonly sourceVerification?: SourceVerification
+}
+
+export type WebFetchCallInput = {
+  readonly url: string
+  readonly prompt: string
+}
+
+export type WebFetchCallContext = {
+  readonly abortController: AbortController
+  readonly options: {
+    readonly isNonInteractiveSession: boolean
+  }
+}

package/tui/src/tools/WebFetchTool/urlSafety.ts

@@ -0,0 +1,181 @@
+import { isIP } from 'node:net'
+
+const MAX_WEB_FETCH_URL_LENGTH = 2000
+
+const INTERNAL_HOSTNAMES = new Set([
+  'localhost',
+  'localhost.localdomain',
+  'ip6-localhost',
+  'ip6-loopback',
+  'metadata',
+  'metadata.google.internal',
+])
+
+const INTERNAL_HOSTNAME_SUFFIXES = [
+  '.localhost',
+  '.local',
+  '.internal',
+  '.intranet',
+  '.lan',
+  '.home',
+  '.corp',
+] as const
+
+export type WebFetchUrlSafetyResult =
+  | {
+      readonly ok: true
+      readonly parsedUrl: URL
+      readonly hostname: string
+    }
+  | {
+      readonly ok: false
+      readonly reason: 'invalid_url' | 'unsafe_url'
+      readonly message: string
+    }
+
+export function validatePublicWebFetchUrl(
+  value: string,
+): WebFetchUrlSafetyResult {
+  if (value.length > MAX_WEB_FETCH_URL_LENGTH) {
+    return unsafeUrl('URL exceeds the WebFetch length limit.')
+  }
+
+  let parsedUrl: URL
+  try {
+    parsedUrl = new URL(value)
+  } catch (error) {
+    if (error instanceof TypeError) {
+      return {
+        ok: false,
+        reason: 'invalid_url',
+        message: `Invalid URL "${value}". The URL provided could not be parsed.`,
+      }
+    }
+    throw error
+  }
+
+  if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+    return unsafeUrl('WebFetch only allows public http or https URLs.')
+  }
+
+  if (parsedUrl.username || parsedUrl.password) {
+    return unsafeUrl('WebFetch URLs must not contain credentials.')
+  }
+
+  const hostname = normalizeHostname(parsedUrl.hostname)
+  if (hostname.length === 0) {
+    return unsafeUrl('WebFetch URL host is empty.')
+  }
+
+  if (isIpAddress(hostname)) {
+    return isNonPublicIpAddress(hostname)
+      ? unsafeUrl('WebFetch cannot access private, loopback, metadata, or link-local IP ranges.')
+      : { ok: true, parsedUrl, hostname }
+  }
+
+  if (isInternalHostname(hostname)) {
+    return unsafeUrl('WebFetch cannot access private, loopback, metadata, or link-local hostnames.')
+  }
+
+  return { ok: true, parsedUrl, hostname }
+}
+
+export function isPublicWebFetchUrl(value: string): boolean {
+  return validatePublicWebFetchUrl(value).ok
+}
+
+function unsafeUrl(message: string): WebFetchUrlSafetyResult {
+  return {
+    ok: false,
+    reason: 'unsafe_url',
+    message,
+  }
+}
+
+function normalizeHostname(hostname: string): string {
+  const lower = hostname.toLowerCase()
+  const withoutBrackets =
+    lower.startsWith('[') && lower.endsWith(']')
+      ? lower.slice(1, lower.length - 1)
+      : lower
+  return withoutBrackets.replace(/\.$/u, '')
+}
+
+function isIpAddress(hostname: string): boolean {
+  return isIP(hostname) !== 0
+}
+
+function isNonPublicIpAddress(hostname: string): boolean {
+  switch (isIP(hostname)) {
+    case 4:
+      return isNonPublicIpv4(hostname)
+    case 6:
+      return isNonPublicIpv6(hostname)
+    default:
+      return true
+  }
+}
+
+function isNonPublicIpv4(hostname: string): boolean {
+  const octets = hostname.split('.').map(value => Number(value))
+  const [first, second] = octets
+  if (
+    octets.length !== 4 ||
+    first === undefined ||
+    second === undefined ||
+    octets.some(octet => !Number.isInteger(octet) || octet < 0 || octet > 255)
+  ) {
+    return true
+  }
+
+  return (
+    first === 0 ||
+    first === 10 ||
+    first === 127 ||
+    first >= 224 ||
+    (first === 100 && second >= 64 && second <= 127) ||
+    (first === 169 && second === 254) ||
+    (first === 172 && second >= 16 && second <= 31) ||
+    (first === 192 && second === 168) ||
+    (first === 198 && (second === 18 || second === 19))
+  )
+}
+
+function isNonPublicIpv6(hostname: string): boolean {
+  const lower = hostname.toLowerCase()
+  if (
+    lower === '::' ||
+    lower === '::1' ||
+    lower.startsWith('::ffff:') ||
+    lower.startsWith('2001:db8:')
+  ) {
+    return true
+  }
+
+  const firstSegment = lower.split(':').find(segment => segment.length > 0)
+  if (firstSegment === undefined) {
+    return true
+  }
+  const firstHextet = Number.parseInt(firstSegment, 16)
+  if (!Number.isInteger(firstHextet)) {
+    return true
+  }
+
+  return (
+    (firstHextet & 0xfe00) === 0xfc00 ||
+    (firstHextet & 0xffc0) === 0xfe80 ||
+    (firstHextet & 0xff00) === 0xff00
+  )
+}
+
+function isInternalHostname(hostname: string): boolean {
+  if (INTERNAL_HOSTNAMES.has(hostname)) {
+    return true
+  }
+
+  if (!hostname.includes('.')) {
+    return true
+  }
+
+  return INTERNAL_HOSTNAME_SUFFIXES.some(suffix => hostname.endsWith(suffix))
+}

package/tui/src/tools/WebFetchTool/utils.ts

@@ -4,7 +4,7 @@ import {
   type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
   logEvent,
 } from '../../services/analytics/index.js'
-import { queryHaiku } from '../../services/api/claude.js'
+import { queryHaiku } from '../../services/api/ummaya.js'
 import { AbortError } from '../../utils/errors.js'
 import { getWebFetchUserAgent } from '../../utils/http.js'
 import { logError } from '../../utils/log.js'

package/tui/src/tools/WebSearchTool/UI.tsx

@@ -98,4 +98,3 @@ export function getToolUseSummary(input: Partial<{
   }
   return truncate(input.query, TOOL_SUMMARY_MAX_LENGTH);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","MessageResponse","TOOL_SUMMARY_MAX_LENGTH","Box","Text","ProgressMessage","truncate","Output","SearchResult","WebSearchProgress","getSearchSummary","results","searchCount","totalResultCount","result","content","length","renderToolUseMessage","query","allowed_domains","blocked_domains","Partial","verbose","ReactNode","message","join","renderToolUseProgressMessage","progressMessages","lastProgress","data","type","resultCount","renderToolResultMessage","output","timeDisplay","durationSeconds","Math","round","getToolUseSummary","input"],"sources":["UI.tsx"],"sourcesContent":["import React from 'react'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { TOOL_SUMMARY_MAX_LENGTH } from '../../constants/toolLimits.js'\nimport { Box, Text } from '../../ink.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { truncate } from '../../utils/format.js'\nimport type {\n  Output,\n  SearchResult,\n  WebSearchProgress,\n} from './WebSearchTool.js'\n\nfunction getSearchSummary(\n  results: (SearchResult | string | null | undefined)[],\n): {\n  searchCount: number\n  totalResultCount: number\n} {\n  let searchCount = 0\n  let totalResultCount = 0\n\n  for (const result of results) {\n    if (result != null && typeof result !== 'string') {\n      searchCount++\n      totalResultCount += result.content?.length ?? 0\n    }\n  }\n\n  return { searchCount, totalResultCount }\n}\n\nexport function renderToolUseMessage(\n  {\n    query,\n    allowed_domains,\n    blocked_domains,\n  }: Partial<{\n    query: string\n    allowed_domains?: string[]\n    blocked_domains?: string[]\n  }>,\n  { verbose }: { verbose: boolean },\n): React.ReactNode {\n  if (!query) {\n    return null\n  }\n\n  let message = ''\n\n  if (query) {\n    message += `\"${query}\"`\n  }\n\n  if (verbose) {\n    if (allowed_domains && allowed_domains.length > 0) {\n      message += `, only allowing domains: ${allowed_domains.join(', ')}`\n    }\n\n    if (blocked_domains && blocked_domains.length > 0) {\n      message += `, blocking domains: ${blocked_domains.join(', ')}`\n    }\n  }\n\n  return message\n}\n\nexport function renderToolUseProgressMessage(\n  progressMessages: ProgressMessage<WebSearchProgress>[],\n): React.ReactNode {\n  if (progressMessages.length === 0) {\n    return null\n  }\n\n  const lastProgress = progressMessages[progressMessages.length - 1]\n  if (!lastProgress?.data) {\n    return null\n  }\n\n  const data = lastProgress.data\n\n  switch (data.type) {\n    case 'query_update':\n      return (\n        <MessageResponse>\n          <Text dimColor>Searching: {data.query}</Text>\n        </MessageResponse>\n      )\n    case 'search_results_received':\n      return (\n        <MessageResponse>\n          <Text dimColor>\n            Found {data.resultCount} results for &quot;{data.query}&quot;\n          </Text>\n        </MessageResponse>\n      )\n    default:\n      return null\n  }\n}\n\nexport function renderToolResultMessage(output: Output): React.ReactNode {\n  const { searchCount } = getSearchSummary(output.results ?? [])\n  const timeDisplay =\n    output.durationSeconds >= 1\n      ? `${Math.round(output.durationSeconds)}s`\n      : `${Math.round(output.durationSeconds * 1000)}ms`\n\n  return (\n    <Box justifyContent=\"space-between\" width=\"100%\">\n      <MessageResponse height={1}>\n        <Text>\n          Did {searchCount} search\n          {searchCount !== 1 ? 'es' : ''} in {timeDisplay}\n        </Text>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nexport function getToolUseSummary(\n  input: Partial<{ query: string }> | undefined,\n): string | null {\n  if (!input?.query) {\n    return null\n  }\n  return truncate(input.query, TOOL_SUMMARY_MAX_LENGTH)\n}\n"],"mappings":"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","ignoreList":[]}