From 8119a2211b7a8f3521305b4bd499ddb465bfea99 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 04:58:00 +0200 Subject: [PATCH 01/25] Define the safe boundary for account-free integration tools Record the explicit local source, credential-provider contract, supported authentication modes, egress controls, and fail-closed non-goals before implementation begins. Constraint: Local integration credentials must never enter model-visible, persisted, logged, URL, or Veryfront API state Rejected: Reuse integrations.allow as a grant surface | it is an established narrowing-only policy Rejected: Fall back implicitly from the hosted remote source | transport and credential ownership would become ambiguous Confidence: high Scope-risk: broad Directive: Keep the local source explicit and preserve the API-backed integration path unchanged Tested: Markdown format, line-width audit, placeholder audit, and diff whitespace Not-tested: Runtime behavior; implementation follows in RED-GREEN tasks --- ...18-local-integration-credentials-design.md | 325 ++++++++++++++++++ 1 file changed, 325 insertions(+) create mode 100644 docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md diff --git a/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md b/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md new file mode 100644 index 0000000000..6254749029 --- /dev/null +++ b/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md @@ -0,0 +1,325 @@ +# Local Integration Credentials Design + +## Status + +Approved product direction from +[`veryfront-issue-inbox#495`](https://github.com/veryfront/veryfront-issue-inbox/issues/495): +provide first-class BYO integration credentials for local and self-hosted Veryfront without a +Veryfront account or control plane. + +This document defines the first implementation slice. It is intentionally narrower than the +hosted integration service. The local path must be explicit, least-privilege, and unable to move +provider credentials into model-visible or remotely persisted state. + +## Problem + +Veryfront agents and delegates already run locally with direct model-provider keys. Native +integration tools do not: `salesforce__*` and other integration tools are listed and executed by +the Veryfront API, which also owns connection lookup and token resolution. A project without a +Veryfront account therefore cannot materialize or execute those tools. + +The framework already has the right runtime seam. A `RemoteToolSource` can list definitions and +execute them, and `loadRemoteToolsFromSource()` turns those definitions into ordinary Veryfront +tools. The missing module is a source backed by the local connector catalog and project-owned +credentials. + +## Goals + +- Let a local or self-hosted project materialize an explicit allowlist of catalog integration + tools without contacting Veryfront. +- Resolve credentials from project-scoped environment variables by default. +- Allow a caller-supplied credential provider for secret managers without accepting raw secrets + in the source configuration. +- Support the connector credential modes needed for representative local use: + - header-based API keys; + - HTTP Basic authentication; + - OAuth2 client credentials; + - Salesforce client-credentials service accounts. +- Preserve canonical tool IDs such as `salesforce__find_customer`. +- Reuse the connector catalog as the source of tool schemas, endpoints, and credential-variable + names. +- Preserve the hosted API-backed integration path unchanged. +- Keep credentials out of prompts, tool metadata, tool arguments, execution context, logs, + diagnostics, URLs, persisted artifacts, and Veryfront API requests. + +## Non-goals + +- General authorization-code OAuth in a headless process. +- Importing or reusing hosted Veryfront connection records. +- Forwarding local credentials to a Veryfront API or hosted tool executor. +- Making `integrations.allow` grant tools or select credentials. It remains a narrowing policy. +- Supporting API-key connectors that put secrets in query parameters or endpoint URL templates. +- Supporting GraphQL, multipart, raw-body, or response-enrichment endpoint contracts in the first + slice. +- Adding a token cache. Client-credentials tokens are minted for each tool execution initially. +- Reproducing every hosted policy, audit, and connection-binding feature locally. + +## Public API + +The new source is exported from `veryfront/integrations`: + +```ts +import { createLocalIntegrationToolSource } from "veryfront/integrations"; +import { loadRemoteToolsFromSource } from "veryfront/tool"; + +const integrationSource = createLocalIntegrationToolSource({ + tools: [ + "salesforce__find_customer", + "salesforce__list_cases", + "salesforce__update_case", + ], +}); + +const integrationTools = await loadRemoteToolsFromSource(integrationSource); +``` + +The public types are: + +```ts +export type LocalIntegrationCredentialProvider = ( + environmentVariableName: string, +) => string | undefined | Promise; + +export interface LocalIntegrationToolSourceOptions { + /** Exact canonical catalog tool IDs granted to this source. */ + tools: readonly string[]; + + /** Defaults to the active project-scoped environment. */ + credentialProvider?: LocalIntegrationCredentialProvider; +} + +export function createLocalIntegrationToolSource( + options: LocalIntegrationToolSourceOptions, +): RemoteToolSource; +``` + +The source ID is stable and framework-owned. Tool order follows the caller's allowlist after +duplicate rejection. The constructor snapshots and validates the options so later caller mutation +cannot widen the source. + +The credential provider receives only a validated canonical environment-variable name. It never +receives tool arguments, execution context, provider URLs, connector metadata, or prior credential +values. Returned values remain inside the source closure and request builder. + +## Authorization model + +Source construction is the grant. Environment-variable presence alone never enables a connector +or tool. + +Each configured value must be an exact canonical catalog tool ID in the form +`integration__tool_id`. The source rejects: + +- malformed IDs; +- duplicates; +- unknown connectors; +- unknown tools; +- tools without endpoint metadata; +- tools whose endpoint or authentication contract is unsupported locally. + +`integrations.allow` and run/source policies continue to narrow the materialized tools through the +existing remote-tool provenance path. They cannot add tools absent from this source. + +The source is unavailable in hosted or multi-project proxy mode. This prevents project code from +using the local path to bypass hosted connection ownership, tool binding, or audit rules. Local +development and single-project self-hosted production remain eligible. + +## Credential resolution + +The default credential provider uses the active project-scoped environment accessor, not a bulk +environment snapshot. A custom provider can bridge a local secret manager. + +`listTools()` validates that every configured connector has a complete supported credential set. +It does not mint tokens or contact a provider. Missing configuration fails before model execution +and names only the missing variables. + +`executeTool()` resolves the credentials again immediately before the provider request. This +avoids retaining raw secrets or stale credential values between calls. + +### Header API key + +The connector's `auth.keyName`, `headerName`, `headerPrefix`, and `additionalHeaders` define the +required variables and headers. Query-parameter authentication and `{{auth.token}}` URL templates +are rejected because secrets in URLs can reach access logs, proxies, and diagnostics. + +### HTTP Basic + +The connector's `usernameKey` and `passwordKey` identify the variables. Optional/default catalog +values retain their current meaning. The source builds the Basic header inside the request +boundary. + +### OAuth2 client credentials + +Only connectors with `grantType: "client_credentials"` are eligible. Credential names derive from +the existing connector vocabulary: `_CLIENT_ID` and +`_CLIENT_SECRET`. The source supports fixed HTTPS token URLs and the catalog's +Basic or request-body client-auth method. Authorization-code connectors remain unsupported. + +### Salesforce service account + +Salesforce's catalog entry describes interactive OAuth and cannot authorize a headless tool call. +The local source therefore uses the same distinct service-identity vocabulary as the hosted API: + +- `SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID` +- `SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET` +- `SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL` + +The login URL must be an HTTPS Salesforce My Domain origin without userinfo, port, query, fragment, +or non-root path. The token response must contain a bounded non-empty access token and an HTTPS +Salesforce instance URL. Salesforce endpoint templates may substitute only that validated instance +origin. + +## Tool definitions + +The model-facing JSON Schema is built from the configured catalog endpoint: + +- endpoint path, query, and header parameters become object properties; +- endpoint body fields become object properties; +- required catalog fields become JSON Schema `required` entries; +- safe catalog defaults appear only when `exposeDefault` is true; +- no credential name or value appears in the schema or description. + +Execution still applies all catalog defaults, including defaults not exposed to the model. + +## Provider request execution + +The first slice supports REST endpoints with: + +- GET, POST, PUT, PATCH, and DELETE; +- path parameters with encoded substitution; +- query parameters; +- caller-controlled headers declared by the catalog; +- JSON object bodies; +- passthrough JSON object/array bodies; +- dotted response transforms such as `records` and `data`. + +The executor validates input against the catalog contract before building a request. Unknown input +fields are rejected. Path values are encoded; query values use `URLSearchParams`; request headers +are constructed independently of caller input. + +Every token and provider request uses `guardedEgressFetch()` with: + +- `redirect: "error"`; +- a bounded timeout combined with the tool execution abort signal; +- the existing DNS/private-address guard; +- an authorization callback that limits a request to the catalog token endpoint or provider + endpoint origin; +- no automatic forwarding of authentication headers to another origin. + +Static catalog endpoints must be HTTPS and contain no userinfo. Dynamic Salesforce hosts must pass +the Salesforce-domain validator before they can reach the egress guard. + +Responses have a bounded byte limit. Non-2xx responses and invalid JSON produce typed Veryfront +errors containing only the connector, tool ID, and HTTP status. Provider bodies, response headers, +URLs with query strings, credentials, and token payloads are never included in public error text, +causes, context, or logs. + +## Error behavior + +Configuration errors are typed Veryfront errors and can safely name: + +- the configured canonical tool ID; +- the connector name; +- unsupported auth or endpoint capability; +- missing environment-variable names. + +They cannot include values returned by the credential provider. + +Provider failures are typed Veryfront errors with stable generic detail. The original provider +error and response body are not attached as a cause because causes can be logged by callers. + +## Hosted compatibility + +The current `getRemoteIntegrationToolDefinitions()` and +`executeRemoteIntegrationTool()` implementations are unchanged. The new source has no implicit +registration and is used only when project code constructs and materializes it. + +No credential is copied into `ToolExecutionContext.authToken`; that field remains the Veryfront +control-plane credential for the existing remote integration source. + +## Test strategy + +RED tests precede each implementation slice. + +### Admission and metadata + +- exact allowlist produces only requested canonical tools; +- duplicate, malformed, unknown, endpoint-less, and unsupported tools fail closed; +- option mutation after construction cannot widen the source; +- hosted and proxy modes reject the local source; +- tool definitions contain no credential names or values; +- source policy still narrows materialized local integration tools. + +### Credentials + +- missing credentials report only variable names; +- a custom provider receives only expected names; +- API-key, additional-header, Basic, and client-credentials headers are correct; +- client credentials use the correct token-auth method; +- Salesforce uses the three service-account variables; +- malformed Salesforce login and instance URLs fail before provider execution; +- interactive OAuth connectors other than Salesforce fail closed; +- query-string credential connectors fail closed. + +### Execution + +- Vercel representative GET builds the correct header and query; +- Sendcloud representative Basic request builds the correct header; +- PayPal mints a client-credentials token and executes with the returned bearer token; +- Salesforce mints a service-account token and executes a `salesforce__*` endpoint against the + returned instance origin; +- path, query, header, JSON body, passthrough body, defaults, and response transforms work; +- unknown input and missing required input fail before transport; +- redirects, private-address destinations, oversized responses, non-2xx responses, invalid JSON, + and aborts are bounded and safe; +- sentinel credentials and provider response secrets are absent from errors, logs, definitions, + serialized tool metadata, and request URLs. + +### Compatibility + +- the API-backed integration source behaves exactly as before when the local source is unused; +- ordinary remote-source materialization and aliases remain unchanged; +- Deno, Node, and Bun package/runtime gates pass. + +## Alternatives considered + +### Extend `integrations.allow` + +Rejected. That configuration is explicitly monotonic and cannot grant capabilities. Making it +select credentials would weaken an established security contract. + +### Put credentials in `ToolExecutionContext` + +Rejected. The context crosses more runtime boundaries, is extensible by callers, and already +contains a Veryfront API credential. Reusing it would conflate trust domains and increase leak +surface. + +### Teach the existing API remote source to fall back to local credentials + +Rejected. An implicit fallback makes the transport and credential owner ambiguous. A distinct +source keeps local and hosted execution auditable and prevents accidental secret forwarding. + +### Support every catalog endpoint and OAuth flow immediately + +Rejected. Authorization-code OAuth needs redirect state, token persistence, user ownership, and +refresh semantics. Complex endpoint bodies and enrichment also need separate bounded contracts. +The first slice covers the account-free service and project credential modes without pretending +to provide hosted parity. + +### Copy provider secrets into a project config object + +Rejected. Raw secrets in config are easy to serialize, persist, inspect, or accidentally bundle. +The source accepts only a name-based credential-provider closure. + +## Rollout and documentation + +The public integration guide will add: + +- the source/materialization example; +- supported credential modes and unsupported connector behavior; +- the exact Salesforce service-account variables; +- a warning that credentials belong in environment/secret-manager storage, not code; +- a statement that the source is local/self-hosted and does not contact Veryfront. + +The Salesforce case-processing sample can then replace its account-free mock tool set with this +source when the three service-account variables are present, while retaining mocks for evaluation +and CI. From 0413f9e26f64dffbb425967cd6134d44fd2132c1 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 04:59:13 +0200 Subject: [PATCH 02/25] Sequence account-free integration delivery through bounded TDD seams Translate the approved credential boundary into admission, authentication, endpoint execution, Salesforce, documentation, verification, and merge-gate tasks with explicit RED and GREEN evidence. Constraint: Each credential-boundary behavior must be locked by a failing regression before implementation Confidence: high Scope-risk: broad Directive: Do not merge until exact-head CI is green and all review threads are resolved Tested: Markdown format, line-width audit, placeholder audit, and diff whitespace Not-tested: Runtime behavior; plan execution starts next --- ...026-08-18-local-integration-credentials.md | 316 ++++++++++++++++++ 1 file changed, 316 insertions(+) create mode 100644 docs/superpowers/plans/2026-08-18-local-integration-credentials.md diff --git a/docs/superpowers/plans/2026-08-18-local-integration-credentials.md b/docs/superpowers/plans/2026-08-18-local-integration-credentials.md new file mode 100644 index 0000000000..dc29c29b77 --- /dev/null +++ b/docs/superpowers/plans/2026-08-18-local-integration-credentials.md @@ -0,0 +1,316 @@ +# Local Integration Credentials Implementation Plan + +> Execute this plan with strict RED -> GREEN TDD. Do not merge until full CI is green and every +> review thread is addressed and resolved. + +**Goal:** Let local and single-project self-hosted Veryfront projects materialize an explicit +allowlist of catalog integration tools with project-owned credentials, including Salesforce +service accounts, without contacting Veryfront. + +**Architecture:** Add a `RemoteToolSource` backed by the generated connector catalog. Keep the +public surface to a canonical tool allowlist plus an optional name-only credential provider. +Split admission/schema generation, credential resolution, and guarded endpoint execution into +small internal modules behind that source. Reuse existing remote-tool materialization and egress +guard boundaries. + +**Tech stack:** TypeScript, Deno tests, Veryfront schemas/errors, `guardedEgressFetch`, generated +connector catalog. + +**Design:** +`docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md` + +--- + +## Task 1: Lock source admission and model metadata + +**Files:** + +- Create: `src/integrations/local-tool-source.test.ts` +- Create: `src/integrations/local-tool-source.ts` +- Modify: `src/integrations/index.ts` +- Modify: `src/integrations/limits.ts` + +### RED + +Add focused tests for: + +1. An exact allowlist of Vercel tools returns only those canonical definitions. +2. Definitions contain endpoint input fields and safe exposed defaults, but no credential names. +3. Malformed, duplicate, unknown, endpoint-less, GraphQL, enrichment, query-secret, and + interactive-OAuth tool requests fail with typed safe errors. +4. Mutating the caller's `tools` array after construction cannot widen the source. +5. Hosted and proxy modes reject listing. +6. `executeTool()` rejects names that were not admitted even when they exist in the catalog. + +Run: + +```bash +deno test --no-check --allow-all src/integrations/local-tool-source.test.ts +``` + +Expected: fail because `createLocalIntegrationToolSource` does not exist. + +### GREEN + +Implement only catalog admission, option snapshotting, stable source ID, definition generation, +and an internal admitted-tool record. Use `parseIntegrationToolIdentity()` and the declared +generated connector catalog directly so explicit Salesforce tools do not depend on catalog +visibility flags. Keep `executeTool()` as the next task's typed unimplemented boundary. + +Add deterministic ceilings for configured tool count and credential length to +`src/integrations/limits.ts`. + +Export the function and public types from `src/integrations/index.ts`. + +Run the focused test until green, then run: + +```bash +deno check src/integrations/local-tool-source.ts src/integrations/index.ts +deno fmt --check src/integrations/local-tool-source.ts \ + src/integrations/local-tool-source.test.ts src/integrations/index.ts \ + src/integrations/limits.ts +deno lint src/integrations/local-tool-source.ts \ + src/integrations/local-tool-source.test.ts src/integrations/index.ts \ + src/integrations/limits.ts +``` + +Commit with Lore trailers describing the explicit grant boundary. + +## Task 2: Resolve credentials without leaking them + +**Files:** + +- Create: `src/integrations/local-credential-auth.test.ts` +- Create: `src/integrations/local-credential-auth.ts` +- Modify: `src/integrations/local-tool-source.ts` +- Modify: `src/integrations/local-tool-source.test.ts` + +### RED + +Add table-driven tests for: + +1. Vercel API-key header resolution. +2. Sendcloud HTTP Basic resolution. +3. PayPal client ID/secret discovery and token-request construction. +4. Salesforce's three service-account variable names. +5. Missing values report only sorted variable names. +6. A custom credential provider receives only expected canonical names. +7. Empty, overlong, accessor-backed, or non-string credential values fail closed. +8. Query-string credentials, URL-token templates, non-fixed client-credential token URLs, and + ordinary authorization-code OAuth are rejected. +9. Sentinel secret values never appear in errors or serialized auth-plan metadata. + +Run: + +```bash +deno test --no-check --allow-all src/integrations/local-credential-auth.test.ts \ + src/integrations/local-tool-source.test.ts +``` + +Expected: fail because local credential resolution is absent. + +### GREEN + +Implement a closure-internal auth plan that separates safe credential names from short-lived +secret values. Default reads use the active project-scoped `getEnv()` accessor. Validate missing +credentials during `listTools()`, but resolve values again during execution. Do not cache raw +credentials or tokens. + +Implement Salesforce My Domain normalization and a token plan distinct from the catalog's +interactive OAuth config. Do not attach provider errors as causes. + +Run the focused tests and static checks until green. Commit with Lore trailers documenting why +credentials remain name-addressed and closure-internal. + +## Task 3: Execute bounded REST endpoints through the egress guard + +**Files:** + +- Create: `src/integrations/local-endpoint-executor.test.ts` +- Create: `src/integrations/local-endpoint-executor.ts` +- Modify: `src/integrations/limits.ts` + +### RED + +Add transport-injected tests for: + +1. Path encoding, query parameters, catalog-declared headers, and safe defaults. +2. JSON object and passthrough JSON bodies. +3. Unknown fields, missing required fields, and wrong primitive shapes fail before transport. +4. Dotted response transforms return the expected result. +5. Redirects use `redirect: "error"` and are never followed. +6. Initial and dynamic hosts pass an exact authorization callback and the existing egress guard. +7. Timeout and caller abort signals cancel the request. +8. Oversized, non-2xx, empty, and invalid JSON responses produce typed bounded errors. +9. Sentinel authorization headers, response bodies, query data, and provider URLs do not appear in + errors, logs, or causes. + +Run: + +```bash +deno test --no-check --allow-all src/integrations/local-endpoint-executor.test.ts +``` + +Expected: fail because the local endpoint executor does not exist. + +### GREEN + +Implement the smallest REST executor described by the design. Its default transport must call +`guardedEgressFetch()`. Expose an internal injected transport only for tests; do not add an +unguarded public fetch override. + +Use bounded response reading and typed Veryfront errors. Apply response transforms after the JSON +body is admitted. Never include raw provider content in diagnostic state. + +Run the focused tests and static checks until green. Commit with Lore trailers documenting the +redirect and response-redaction constraints. + +## Task 4: Wire authentication and Salesforce end to end + +**Files:** + +- Modify: `src/integrations/local-tool-source.ts` +- Modify: `src/integrations/local-tool-source.test.ts` +- Modify: `src/integrations/local-credential-auth.ts` +- Modify: `src/integrations/local-endpoint-executor.ts` + +### RED + +Add source-level integration tests for: + +1. Vercel executes a GET with its bearer API key. +2. Sendcloud executes with HTTP Basic. +3. PayPal mints a client-credentials token, then calls the endpoint with the returned bearer token. +4. Salesforce mints a service-account token, validates `instance_url`, substitutes only the + instance origin, and executes `salesforce__find_customer`. +5. Salesforce rejects generic login hosts, private hosts, paths, ports, userinfo, malformed token + payloads, and non-Salesforce instance hosts before an endpoint call. +6. A tool omitted from the source allowlist cannot borrow another admitted connector credential. +7. Source-policy narrowing still rejects a locally materialized canonical integration tool. +8. The API-backed remote integration functions make the same requests as before when this source + is unused. + +Run: + +```bash +deno test --no-check --allow-all \ + src/integrations/local-tool-source.test.ts \ + src/integrations/remote-tools.test.ts \ + src/agent/runtime/tool-helpers.test.ts +``` + +Expected: the new end-to-end cases fail before the source delegates to authentication and endpoint +execution. + +### GREEN + +Wire the admitted tool record to credential resolution, token minting, endpoint URL resolution, +and the guarded executor. Combine the execution abort signal with the local deadline. Keep every +secret in function-local state. + +Run the focused tests and static checks until green. Commit with Lore trailers documenting the +Salesforce specialization and hosted-path compatibility. + +## Task 5: Document the account-free usage contract + +**Files:** + +- Modify: `docs/guides/integrations.md` +- Modify: `docs/guides/integrations/salesforce.md` +- Modify: `docs/guides/self-hosting.md` +- Modify: relevant guide contract tests if present +- Regenerate: `docs/api-reference/veryfront/integrations.md` + +### RED + +Add or strengthen documentation contract tests to require: + +1. The `createLocalIntegrationToolSource()` and `loadRemoteToolsFromSource()` account-free example. +2. The exact Salesforce service-account variables. +3. A statement that local source construction is the grant and `integrations.allow` only narrows. +4. Explicit unsupported authorization-code and query-secret behavior. +5. A statement that local credentials never go to Veryfront. + +Run the focused docs test and confirm it fails before copy changes. + +### GREEN + +Update the integration, Salesforce, and self-hosting guides. Replace the stale claim that remote +integrations have no standalone credential path with the supported subset and limitations. +Regenerate API reference using the repository-pinned Deno version. + +Run: + +```bash +deno task docs:public:validate +deno task docs:api-reference:check +deno fmt --check docs/guides/integrations.md \ + docs/guides/integrations/salesforce.md docs/guides/self-hosting.md +``` + +Commit with Lore trailers documenting the compatibility limits. + +## Task 6: Full verification and adversarial review + +**Files:** all changed files + +Run focused tests first, then repository gates: + +```bash +deno test --no-check --allow-all \ + src/integrations/local-tool-source.test.ts \ + src/integrations/local-credential-auth.test.ts \ + src/integrations/local-endpoint-executor.test.ts \ + src/integrations/remote-tools.test.ts \ + src/tool/remote-source-tools.test.ts \ + src/agent/runtime/tool-helpers.test.ts +deno task check +deno task lint:ci +deno task test +deno task build:npm +git diff --check origin/main...HEAD +``` + +Inspect every output. Fix failures and rerun the exact failed gate plus the full affected matrix. + +Run independent Spec and Standards reviews plus a security review focused on: + +- credential exfiltration through errors, logs, URLs, metadata, context, and provider redirects; +- SSRF/DNS rebinding and Salesforce dynamic-host validation; +- capability widening through environment presence, aliases, source policy, or unsupported tools; +- hosted/proxy-mode bypass; +- primordial/accessor execution at the project-code trust boundary; +- Node, Bun, and Deno package behavior. + +Address every actionable finding with another RED -> GREEN cycle. + +## Task 7: PR, CI, comments, and merge + +Push the branch and open a PR linked to inbox issue #495. The PR body must include: + +- exact account-free public usage; +- supported and unsupported auth/endpoint modes; +- credential/redaction threat model; +- RED and GREEN evidence; +- focused and full verification commands; +- sample follow-up status. + +Monitor all checks and review threads. For each actionable comment: + +1. Reproduce it. +2. Add a failing regression test. +3. Implement the minimal fix. +4. Rerun focused and full affected gates. +5. Reply with evidence and resolve the thread. + +Do not merge until: + +- every required CI check is green on the exact head; +- CodeQL/security checks are green; +- every non-outdated review thread is addressed and resolved; +- independent Spec, Standards, and security reviews approve; +- the merge queue replacement checks are green. + +After merge, verify main CI. Update issue #495 with the merge commit, exact supported contract, +remaining sample work, and release status. Keep the issue open until the Salesforce sample runs +account-free with the real local source or explicitly track that remaining acceptance separately. From bd8bb68f90c628249e461c3e87dd1f0fd75447d8 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:03:12 +0200 Subject: [PATCH 03/25] Prevent implicit capability grants in local integration sources Introduce an explicit catalog tool allowlist, snapshot it before project mutation, emit credential-free model schemas, and reject unsupported endpoint/auth contracts before any provider request exists. Constraint: Environment credential presence must never enable a tool by itself Rejected: Reuse catalog visibility as the local grant | explicit Salesforce service tools must work without widening public catalog/scaffolding visibility Confidence: high Scope-risk: moderate Directive: Keep source construction as the grant and integrations.allow as narrowing-only Tested: 5 focused Deno steps; deno check; deno fmt; deno lint; git diff --check Not-tested: Credential resolution and provider execution follow in later TDD seams --- src/integrations/index.ts | 5 + src/integrations/limits.ts | 3 + src/integrations/local-tool-source.test.ts | 138 +++++++++ src/integrations/local-tool-source.ts | 345 +++++++++++++++++++++ 4 files changed, 491 insertions(+) create mode 100644 src/integrations/local-tool-source.test.ts create mode 100644 src/integrations/local-tool-source.ts diff --git a/src/integrations/index.ts b/src/integrations/index.ts index d7e33851ec..6696624b56 100644 --- a/src/integrations/index.ts +++ b/src/integrations/index.ts @@ -77,4 +77,9 @@ export { isRemoteIntegrationTool, } from "./remote-tools.ts"; export type { RemoteIntegrationToolDiscoveryResult } from "./remote-tools.ts"; +export { createLocalIntegrationToolSource } from "./local-tool-source.ts"; +export type { + LocalIntegrationCredentialProvider, + LocalIntegrationToolSourceOptions, +} from "./local-tool-source.ts"; export type { IntegrationConnector, IntegrationTool } from "./types.ts"; diff --git a/src/integrations/limits.ts b/src/integrations/limits.ts index afcb519e25..4a2e28f3a2 100644 --- a/src/integrations/limits.ts +++ b/src/integrations/limits.ts @@ -25,6 +25,9 @@ export const MAX_INTEGRATION_API_ERROR_RESPONSE_BYTES = 4 * 1024; /** Maximum number of remote tool definitions admitted atomically. */ export const MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS = 1_000; +/** Maximum exact catalog tool grants admitted into one local integration source. */ +export const MAX_LOCAL_INTEGRATION_TOOLS = 256; + /** Maximum caller or environment credential length admitted into an HTTP header. */ export const MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH = 16_384; diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts new file mode 100644 index 0000000000..f972857148 --- /dev/null +++ b/src/integrations/local-tool-source.test.ts @@ -0,0 +1,138 @@ +import "#veryfront/schemas/_test-setup.ts"; +import { + _resetEnvironmentConfig, + _setEnvironmentConfigForTesting, +} from "#veryfront/config/environment-config.ts"; +import { VeryfrontError } from "#veryfront/errors"; +import { assert, assertEquals, assertRejects } from "#veryfront/testing/assert.ts"; +import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; +import { createLocalIntegrationToolSource } from "./index.ts"; + +const TEST_CREDENTIAL = "LOCAL_INTEGRATION_SECRET_MUST_NOT_LEAK"; +const testCredentialProvider = () => TEST_CREDENTIAL; + +async function assertConfigurationError( + createPromise: () => Promise, + expectedDetail: string, +): Promise { + const error = await assertRejects(createPromise, VeryfrontError); + assertEquals(error.slug, "local-integration-config-invalid"); + assert(error.message.includes(expectedDetail), error.message); + assertEquals(error.message.includes(TEST_CREDENTIAL), false); +} + +describe("createLocalIntegrationToolSource", () => { + afterEach(() => _resetEnvironmentConfig()); + + it("lists only explicitly granted catalog tools with credential-free metadata", async () => { + const source = createLocalIntegrationToolSource({ + tools: ["vercel__get_project", "vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + + const definitions = await source.listTools(); + + assertEquals(source.id, "veryfront-local-integrations"); + assertEquals(definitions.map((definition) => definition.name), [ + "vercel__get_project", + "vercel__list_projects", + ]); + assertEquals(definitions[0]?.parameters, { + type: "object", + properties: { + idOrName: { + type: "string", + description: "Project ID (prj_...) or project name", + }, + teamId: { + type: "string", + description: "Team ID to perform the request on behalf of", + }, + slug: { + type: "string", + description: "Team slug, alternative to teamId", + }, + }, + required: ["idOrName"], + additionalProperties: false, + }); + + const serialized = JSON.stringify(definitions); + assertEquals(serialized.includes("VERCEL_TOKEN"), false); + assertEquals(serialized.includes(TEST_CREDENTIAL), false); + }); + + it("snapshots its allowlist before caller mutation", async () => { + const tools = ["vercel__list_projects"]; + const source = createLocalIntegrationToolSource({ + tools, + credentialProvider: testCredentialProvider, + }); + + tools.push("vercel__get_project"); + + assertEquals((await source.listTools()).map((definition) => definition.name), [ + "vercel__list_projects", + ]); + }); + + it("fails closed for malformed, unknown, duplicate, and unsupported tools", async () => { + const fixtures = [ + { tool: "vercel", detail: "canonical" }, + { tool: "vercel__missing", detail: "unknown" }, + { tool: "aws__list-s3-buckets", detail: "endpoint" }, + { tool: "github__list_issues", detail: "GraphQL" }, + { tool: "gmail__list_emails", detail: "enrichment" }, + { tool: "alphavantage__quote", detail: "query" }, + { tool: "slack__list_channels", detail: "authorization-code" }, + ] as const; + + for (const fixture of fixtures) { + await assertConfigurationError(async () => { + const source = createLocalIntegrationToolSource({ + tools: [fixture.tool], + credentialProvider: testCredentialProvider, + }); + await source.listTools(); + }, fixture.detail); + } + + await assertConfigurationError(async () => { + const duplicateSource = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects", "vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + await duplicateSource.listTools(); + }, "duplicate"); + }); + + it("rejects local credential execution in hosted and proxy runtimes", async () => { + for ( + const environment of [ + { veryfrontMode: "hosted", proxyMode: false }, + { veryfrontMode: "production", proxyMode: true }, + ] + ) { + _setEnvironmentConfigForTesting(environment); + const source = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + + await assertConfigurationError(() => source.listTools(), "local or self-hosted"); + _resetEnvironmentConfig(); + } + }); + + it("never executes a catalog tool outside its exact source grant", async () => { + const source = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + + await assertConfigurationError( + () => source.executeTool("vercel__get_project", { idOrName: "demo" }), + "not granted", + ); + }); +}); diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts new file mode 100644 index 0000000000..2d43eee11f --- /dev/null +++ b/src/integrations/local-tool-source.ts @@ -0,0 +1,345 @@ +import { getEnvironmentConfig } from "#veryfront/config/environment-config.ts"; +import { defineError } from "#veryfront/errors"; +import type { JsonSchema } from "#veryfront/extensions/schema/index.ts"; +import type { + RemoteToolSource, + ToolDefinition, + ToolExecutionContext, +} from "#veryfront/tool/types.ts"; +import { connectors } from "./_data.ts"; +import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; +import { parseIntegrationToolIdentity } from "./source-policy.ts"; +import type { IntegrationConfig, IntegrationToolMeta } from "./schema.ts"; + +const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ + slug: "local-integration-config-invalid", + category: "CONFIG", + status: 400, + title: "Invalid local integration configuration", + suggestion: "Use exact catalog tool IDs and supported local credential and endpoint contracts", +}); + +/** Resolve one local integration credential by its canonical environment-variable name. */ +export type LocalIntegrationCredentialProvider = ( + environmentVariableName: string, +) => string | undefined | Promise; + +/** Options for a catalog-backed local integration tool source. */ +export interface LocalIntegrationToolSourceOptions { + /** Exact canonical catalog tool IDs granted to this source. */ + tools: readonly string[]; + /** Defaults to the active project-scoped environment. */ + credentialProvider?: LocalIntegrationCredentialProvider; +} + +type IntegrationEndpoint = NonNullable; + +interface AdmittedLocalIntegrationTool { + readonly connector: IntegrationConfig; + readonly endpoint: IntegrationEndpoint; + readonly tool: IntegrationToolMeta & { id: string }; + readonly definition: ToolDefinition; +} + +function configurationError(detail: string): never { + throw LOCAL_INTEGRATION_CONFIG_INVALID.create({ detail }); +} + +function readOwnDataProperty( + value: object, + key: PropertyKey, +): { present: boolean; value: unknown } { + const descriptor = Reflect.getOwnPropertyDescriptor(value, key); + if (!descriptor) return { present: false, value: undefined }; + if (!("value" in descriptor)) { + configurationError(`Local integration option "${String(key)}" must be a data property`); + } + return { present: true, value: descriptor.value }; +} + +function snapshotOptions(options: LocalIntegrationToolSourceOptions): { + tools: readonly string[]; + credentialProvider: LocalIntegrationCredentialProvider | undefined; +} { + if (typeof options !== "object" || options === null || Array.isArray(options)) { + configurationError("Local integration options must be an object"); + } + + const toolsValue = readOwnDataProperty(options, "tools").value; + if (!Array.isArray(toolsValue)) { + configurationError("Local integration tools must be an array of canonical tool IDs"); + } + if (toolsValue.length === 0) { + configurationError("Local integration tools must include at least one canonical tool ID"); + } + if (toolsValue.length > MAX_LOCAL_INTEGRATION_TOOLS) { + configurationError( + `Local integration tools exceed the ${MAX_LOCAL_INTEGRATION_TOOLS} tool limit`, + ); + } + + const tools: string[] = []; + for (let index = 0; index < toolsValue.length; index++) { + const item = readOwnDataProperty(toolsValue, index); + if (!item.present || typeof item.value !== "string") { + configurationError("Local integration tools must contain only canonical string IDs"); + } + tools.push(item.value); + } + + const providerValue = readOwnDataProperty(options, "credentialProvider"); + if ( + providerValue.present && providerValue.value !== undefined && + typeof providerValue.value !== "function" + ) { + configurationError("Local integration credentialProvider must be a function"); + } + + return { + tools: Object.freeze(tools), + credentialProvider: providerValue.value as LocalIntegrationCredentialProvider | undefined, + }; +} + +function declaredConnector(name: string): IntegrationConfig | undefined { + for (let index = 0; index < connectors.length; index++) { + const connector = connectors[index]; + if (connector?.name === name) return connector; + } + return undefined; +} + +function catalogTool( + connector: IntegrationConfig, + canonicalToolId: string, +): (IntegrationToolMeta & { id: string }) | undefined { + for (let index = 0; index < connector.tools.length; index++) { + const tool = connector.tools[index]; + const catalogId = tool?.id ?? tool?.name; + if ( + catalogId === canonicalToolId || + (catalogId !== undefined && `${connector.name}__${catalogId}` === canonicalToolId) + ) { + if (typeof tool?.name !== "string" || typeof tool.description !== "string") { + configurationError(`Local integration tool "${canonicalToolId}" has invalid metadata`); + } + return Object.freeze({ + ...tool, + id: canonicalToolId, + name: tool.name, + description: tool.description, + }); + } + } + return undefined; +} + +function assertHttpsCatalogUrl(value: string, label: string): void { + let parsed: URL; + try { + parsed = new URL(value); + } catch { + configurationError(`${label} must be a fixed HTTPS URL`); + } + if ( + parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || + value.includes("{{") + ) { + configurationError(`${label} must be a fixed HTTPS URL without credentials`); + } +} + +function assertSupportedAuth( + connector: IntegrationConfig, + endpoint: IntegrationEndpoint, +): void { + const auth = connector.auth; + if (connector.name === "salesforce") return; + + if (auth.type === "api-key") { + if (auth.queryParamName || endpoint.url.includes("{{auth.token}}")) { + configurationError( + `Local integration "${connector.name}" uses query or URL credentials, which are unsupported`, + ); + } + if (!auth.keyName) { + configurationError(`Local integration "${connector.name}" is missing its API-key name`); + } + return; + } + + if (auth.type === "basic") { + if (!auth.usernameKey || !auth.passwordKey) { + configurationError(`Local integration "${connector.name}" is missing Basic credential names`); + } + return; + } + + if (auth.type === "oauth2" && auth.grantType === "client_credentials") { + if (!auth.tokenUrl) { + configurationError(`Local integration "${connector.name}" is missing its token URL`); + } + assertHttpsCatalogUrl(auth.tokenUrl, `Local integration "${connector.name}" token URL`); + return; + } + + configurationError( + `Local integration "${connector.name}" uses unsupported authorization-code credentials`, + ); +} + +function assertSupportedEndpoint( + connector: IntegrationConfig, + endpoint: IntegrationEndpoint, + toolId: string, +): void { + if (endpoint.type === "graphql") { + configurationError(`Local integration tool "${toolId}" uses unsupported GraphQL execution`); + } + if (endpoint.response?.enrich) { + configurationError(`Local integration tool "${toolId}" uses unsupported response enrichment`); + } + if (endpoint.bodyMode === "form-data" || endpoint.bodyMode === "raw") { + configurationError(`Local integration tool "${toolId}" uses an unsupported body mode`); + } + for (const field of Object.values(endpoint.body ?? {})) { + if (field.encoding || field.partFilenameField) { + configurationError(`Local integration tool "${toolId}" uses an unsupported encoded body`); + } + } + + if (connector.name === "salesforce") { + if (!endpoint.url.startsWith("{{oauth.raw.instance_url}}/")) { + configurationError(`Local Salesforce tool "${toolId}" has an unsupported endpoint template`); + } + } else { + assertHttpsCatalogUrl(endpoint.url, `Local integration tool "${toolId}" endpoint`); + } +} + +function inputPropertySchema( + field: { + type: string; + description: string; + default?: unknown; + exposeDefault?: boolean; + }, +): JsonSchema { + if ( + field.type !== "string" && field.type !== "number" && field.type !== "boolean" && + field.type !== "string[]" && field.type !== "object" && field.type !== "array" + ) { + configurationError(`Local integration input uses unsupported type "${field.type}"`); + } + const schema: Record = { + type: field.type === "string[]" ? "array" : field.type, + description: field.description, + }; + if (field.type === "string[]") schema.items = { type: "string" }; + if (field.exposeDefault === true && field.default !== undefined) { + schema.default = field.default; + } + return schema as JsonSchema; +} + +function toolDefinition( + tool: IntegrationToolMeta & { id: string }, + endpoint: IntegrationEndpoint, +): ToolDefinition { + const properties: Record = {}; + const required: string[] = []; + + for (const [name, parameter] of Object.entries(endpoint.params ?? {})) { + properties[name] = inputPropertySchema(parameter); + if (parameter.required) required.push(name); + } + for (const [name, field] of Object.entries(endpoint.body ?? {})) { + if (properties[name]) { + configurationError(`Local integration tool "${tool.id}" declares duplicate input "${name}"`); + } + properties[name] = inputPropertySchema(field); + if (field.required) required.push(name); + } + + return Object.freeze({ + name: tool.id, + description: tool.description, + parameters: Object.freeze({ + type: "object", + properties: Object.freeze(properties), + required: Object.freeze(required), + additionalProperties: false, + }) as JsonSchema, + }); +} + +function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { + const identity = parseIntegrationToolIdentity(canonicalToolId); + if (!identity) { + configurationError(`Local integration tool "${canonicalToolId}" must use a canonical ID`); + } + + const connector = declaredConnector(identity.integration); + if (!connector) { + configurationError(`Local integration tool "${canonicalToolId}" names an unknown connector`); + } + const tool = catalogTool(connector, canonicalToolId); + if (!tool) { + configurationError(`Local integration tool "${canonicalToolId}" is unknown`); + } + if (!tool.endpoint) { + configurationError(`Local integration tool "${canonicalToolId}" has no executable endpoint`); + } + + assertSupportedEndpoint(connector, tool.endpoint, canonicalToolId); + assertSupportedAuth(connector, tool.endpoint); + return Object.freeze({ + connector, + endpoint: tool.endpoint, + tool, + definition: toolDefinition(tool, tool.endpoint), + }); +} + +function assertLocalRuntime(): void { + const environment = getEnvironmentConfig(); + if (environment.proxyMode || environment.veryfrontMode === "hosted") { + configurationError( + "Local integration credentials are available only in local or self-hosted runtimes", + ); + } +} + +/** Create an explicitly granted, catalog-backed local integration tool source. */ +export function createLocalIntegrationToolSource( + options: LocalIntegrationToolSourceOptions, +): RemoteToolSource { + const snapshot = snapshotOptions(options); + const admitted = new Map(); + + for (const toolId of snapshot.tools) { + if (admitted.has(toolId)) { + configurationError(`Local integration tool "${toolId}" is a duplicate grant`); + } + admitted.set(toolId, admitTool(toolId)); + } + + return Object.freeze({ + id: "veryfront-local-integrations", + async listTools(): Promise { + assertLocalRuntime(); + return snapshot.tools.map((toolId) => admitted.get(toolId)!.definition); + }, + async executeTool( + toolName: string, + _args: Record, + _context?: ToolExecutionContext, + ): Promise { + assertLocalRuntime(); + if (!admitted.has(toolName)) { + configurationError(`Local integration tool "${toolName}" is not granted by this source`); + } + configurationError(`Local integration tool "${toolName}" execution is not implemented`); + }, + }); +} From 9f3a2a4690dcfd97ca4d129fe879456ceab1268e Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:06:56 +0200 Subject: [PATCH 04/25] Keep local provider secrets inside a name-addressed credential boundary Separate serializable catalog auth plans from short-lived resolved headers and token requests, validate readiness before tool exposure, and support API-key, Basic, client-credentials, and Salesforce service-account vocabularies. Constraint: Credential providers receive only canonical environment-variable names and provider failures cannot carry secret causes Rejected: Store raw credentials on the tool source | source objects and metadata are model/runtime-visible for longer than one request Confidence: high Scope-risk: moderate Directive: Do not add raw credential values to plans, errors, contexts, caches, or logs Tested: 13 focused Deno steps; deno check; deno fmt; deno lint; git diff --check Not-tested: Provider HTTP transport and token-response handling follow in the endpoint execution seam --- .../local-credential-auth.test.ts | 209 +++++++++ src/integrations/local-credential-auth.ts | 397 ++++++++++++++++++ src/integrations/local-integration-errors.ts | 29 ++ src/integrations/local-tool-source.test.ts | 17 + src/integrations/local-tool-source.ts | 28 +- 5 files changed, 670 insertions(+), 10 deletions(-) create mode 100644 src/integrations/local-credential-auth.test.ts create mode 100644 src/integrations/local-credential-auth.ts create mode 100644 src/integrations/local-integration-errors.ts diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts new file mode 100644 index 0000000000..8183b9eac1 --- /dev/null +++ b/src/integrations/local-credential-auth.test.ts @@ -0,0 +1,209 @@ +import "#veryfront/schemas/_test-setup.ts"; +import { VeryfrontError } from "#veryfront/errors"; +import { assert, assertEquals, assertRejects } from "#veryfront/testing/assert.ts"; +import { describe, it } from "#veryfront/testing/bdd.ts"; +import { connectors } from "./_data.ts"; +import { + createLocalCredentialAuthPlan, + resolveLocalCredentialAuth, +} from "./local-credential-auth.ts"; +import type { LocalIntegrationCredentialProvider } from "./local-tool-source.ts"; + +const SECRET = "LOCAL_PROVIDER_SECRET_MUST_NOT_LEAK"; + +function connector(name: string) { + const value = connectors.find((candidate) => candidate.name === name); + assert(value, `Missing test connector ${name}`); + return value; +} + +function providerFrom(values: Record): LocalIntegrationCredentialProvider { + return (name) => values[name]; +} + +describe("local integration credential auth", () => { + it("resolves header API-key and additional-header plans", async () => { + const vercelPlan = createLocalCredentialAuthPlan(connector("vercel")); + assertEquals(vercelPlan.requiredEnvironmentVariables, ["VERCEL_TOKEN"]); + assertEquals(JSON.stringify(vercelPlan).includes(SECRET), false); + + const vercel = await resolveLocalCredentialAuth( + vercelPlan, + providerFrom({ VERCEL_TOKEN: SECRET }), + ); + assertEquals(vercel.kind, "headers"); + assertEquals(vercel.headers, { Authorization: `Bearer ${SECRET}` }); + + const datadogPlan = createLocalCredentialAuthPlan(connector("datadog")); + const datadog = await resolveLocalCredentialAuth( + datadogPlan, + providerFrom({ + DD_API_KEY: "api-key", + DD_APP_KEY: "app-key", + }), + ); + assertEquals(datadog.kind, "headers"); + assertEquals(datadog.headers, { + "DD-API-KEY": "api-key", + "DD-APPLICATION-KEY": "app-key", + }); + }); + + it("resolves HTTP Basic without exposing credentials in the safe plan", async () => { + const plan = createLocalCredentialAuthPlan(connector("sendcloud")); + assertEquals(plan.requiredEnvironmentVariables, [ + "SENDCLOUD_PUBLIC_KEY", + "SENDCLOUD_SECRET_KEY", + ]); + + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + SENDCLOUD_PUBLIC_KEY: "public-key", + SENDCLOUD_SECRET_KEY: SECRET, + }), + ); + + assertEquals(resolved.kind, "headers"); + assertEquals(resolved.headers, { + Authorization: `Basic ${btoa(`public-key:${SECRET}`)}`, + }); + assertEquals(JSON.stringify(plan).includes(SECRET), false); + }); + + it("builds a PayPal client-credentials token request", async () => { + const plan = createLocalCredentialAuthPlan(connector("paypal")); + assertEquals(plan.requiredEnvironmentVariables, [ + "PAYPAL_CLIENT_ID", + "PAYPAL_CLIENT_SECRET", + ]); + + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + PAYPAL_CLIENT_ID: "paypal-client", + PAYPAL_CLIENT_SECRET: SECRET, + }), + ); + + assertEquals(resolved.kind, "token-request"); + assertEquals(resolved.mode, "client-credentials"); + assertEquals(resolved.url, "https://api-m.paypal.com/v1/oauth2/token"); + assertEquals(resolved.headers, { + Accept: "application/json", + Authorization: `Basic ${btoa(`paypal-client:${SECRET}`)}`, + "Content-Type": "application/x-www-form-urlencoded", + }); + assertEquals(resolved.body, "grant_type=client_credentials"); + }); + + it("builds a Salesforce service-account token request from its distinct vocabulary", async () => { + const plan = createLocalCredentialAuthPlan(connector("salesforce")); + assertEquals(plan.requiredEnvironmentVariables, [ + "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID", + "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET", + "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL", + ]); + + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID: "salesforce-client", + SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET: SECRET, + SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL: "https://acme.my.salesforce.com", + }), + ); + + assertEquals(resolved.kind, "token-request"); + assertEquals(resolved.mode, "salesforce-service-account"); + assertEquals(resolved.url, "https://acme.my.salesforce.com/services/oauth2/token"); + assertEquals(resolved.headers, { + Accept: "application/json", + "Content-Type": "application/x-www-form-urlencoded", + }); + assertEquals( + resolved.body, + `grant_type=client_credentials&client_id=salesforce-client&client_secret=${SECRET}`, + ); + }); + + it("reports only missing variable names and calls a provider with names only", async () => { + const calls: string[] = []; + const plan = createLocalCredentialAuthPlan(connector("sendcloud")); + const error = await assertRejects( + () => + resolveLocalCredentialAuth(plan, (name) => { + calls.push(name); + return name === "SENDCLOUD_PUBLIC_KEY" ? "public-key" : undefined; + }), + VeryfrontError, + ); + + assertEquals(calls, ["SENDCLOUD_PUBLIC_KEY", "SENDCLOUD_SECRET_KEY"]); + assertEquals(error.slug, "local-integration-credentials-missing"); + assert(error.message.includes("SENDCLOUD_SECRET_KEY")); + assertEquals(error.message.includes("public-key"), false); + assertEquals(error.cause, undefined); + }); + + it("fails safely for invalid values, provider failures, and Salesforce login URLs", async () => { + const plan = createLocalCredentialAuthPlan(connector("vercel")); + for (const value of ["", " ", "x".repeat(16_385)]) { + const error = await assertRejects( + () => resolveLocalCredentialAuth(plan, () => value), + VeryfrontError, + ); + assertEquals(error.slug, "local-integration-credentials-missing"); + if (value.length > 16_384) { + assertEquals(error.message.includes(value), false); + } + } + + const providerError = await assertRejects( + () => + resolveLocalCredentialAuth(plan, () => { + throw new Error(SECRET); + }), + VeryfrontError, + ); + assertEquals(providerError.slug, "local-integration-credential-unavailable"); + assertEquals(providerError.message.includes(SECRET), false); + assertEquals(providerError.cause, undefined); + + const salesforcePlan = createLocalCredentialAuthPlan(connector("salesforce")); + for ( + const loginUrl of [ + "http://acme.my.salesforce.com", + "https://login.salesforce.com", + "https://acme.my.salesforce.com/path", + "https://user@acme.my.salesforce.com", + "https://acme.my.salesforce.com:8443", + ] + ) { + const error = await assertRejects( + () => + resolveLocalCredentialAuth( + salesforcePlan, + providerFrom({ + SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID: "client", + SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET: SECRET, + SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL: loginUrl, + }), + ), + VeryfrontError, + ); + assertEquals(error.slug, "local-integration-config-invalid"); + assertEquals(error.message.includes(SECRET), false); + } + }); + + it("rejects URL credentials and authorization-code OAuth in the auth module", async () => { + for (const name of ["alphavantage", "slack"]) { + const error = await assertRejects( + async () => createLocalCredentialAuthPlan(connector(name)), + VeryfrontError, + ); + assertEquals(error.slug, "local-integration-config-invalid"); + } + }); +}); diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts new file mode 100644 index 0000000000..f6d5e85d5b --- /dev/null +++ b/src/integrations/local-credential-auth.ts @@ -0,0 +1,397 @@ +import type { LocalIntegrationCredentialProvider } from "./local-tool-source.ts"; +import type { IntegrationConfig } from "./schema.ts"; +import { + LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, + LOCAL_INTEGRATION_CREDENTIALS_MISSING, + localIntegrationConfigurationError, +} from "./local-integration-errors.ts"; +import { MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH } from "./limits.ts"; + +const apply = Reflect.apply; +const encodeUriComponent = encodeURIComponent; +const freeze = Object.freeze; +const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +const stringEndsWith = String.prototype.endsWith; +const stringToLowerCase = String.prototype.toLowerCase; +const stringTrim = String.prototype.trim; +const textEncoder = new TextEncoder(); +const textEncoderEncode = TextEncoder.prototype.encode; +const URLConstructor = URL; +const urlHash = getOwnPropertyDescriptor(URL.prototype, "hash")?.get; +const urlHostname = getOwnPropertyDescriptor(URL.prototype, "hostname")?.get; +const urlPassword = getOwnPropertyDescriptor(URL.prototype, "password")?.get; +const urlPathname = getOwnPropertyDescriptor(URL.prototype, "pathname")?.get; +const urlPort = getOwnPropertyDescriptor(URL.prototype, "port")?.get; +const urlProtocol = getOwnPropertyDescriptor(URL.prototype, "protocol")?.get; +const urlSearch = getOwnPropertyDescriptor(URL.prototype, "search")?.get; +const urlUsername = getOwnPropertyDescriptor(URL.prototype, "username")?.get; + +interface LocalCredentialAuthPlanBase { + readonly connectorName: string; + readonly requiredEnvironmentVariables: readonly string[]; +} + +interface LocalApiKeyAuthPlan extends LocalCredentialAuthPlanBase { + readonly kind: "api-key"; + readonly keyName: string; + readonly headerName: string; + readonly headerPrefix?: string; + readonly additionalHeaders: Readonly>; +} + +interface LocalBasicAuthPlan extends LocalCredentialAuthPlanBase { + readonly kind: "basic"; + readonly usernameName: string; + readonly passwordName: string; + readonly passwordFallback?: string; +} + +interface LocalClientCredentialsAuthPlan extends LocalCredentialAuthPlanBase { + readonly kind: "client-credentials"; + readonly clientIdName: string; + readonly clientSecretName: string; + readonly scopes: readonly string[]; + readonly tokenAuthMethod: "basic" | "request-body"; + readonly tokenUrl: string; +} + +interface LocalSalesforceServiceAccountAuthPlan extends LocalCredentialAuthPlanBase { + readonly kind: "salesforce-service-account"; + readonly clientIdName: "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID"; + readonly clientSecretName: "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET"; + readonly loginUrlName: "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL"; +} + +export type LocalCredentialAuthPlan = + | LocalApiKeyAuthPlan + | LocalBasicAuthPlan + | LocalClientCredentialsAuthPlan + | LocalSalesforceServiceAccountAuthPlan; + +export interface ResolvedLocalHeaderAuth { + readonly kind: "headers"; + readonly connectorName: string; + readonly headers: Readonly>; +} + +export interface ResolvedLocalTokenRequest { + readonly kind: "token-request"; + readonly connectorName: string; + readonly mode: "client-credentials" | "salesforce-service-account"; + readonly url: string; + readonly headers: Readonly>; + readonly body: string; +} + +export type ResolvedLocalCredentialAuth = + | ResolvedLocalHeaderAuth + | ResolvedLocalTokenRequest; + +function stringCall( + operation: (this: string, ...args: never[]) => string, + value: string, +): string { + return apply(operation, value, []); +} + +function stringEndsWithValue(value: string, suffix: string): boolean { + return apply(stringEndsWith, value, [suffix]); +} + +function urlValue(getter: ((this: URL) => string) | undefined, url: URL): string { + if (!getter) localIntegrationConfigurationError("URL parsing is unavailable in this runtime"); + return apply(getter, url, []); +} + +function parseUrl(value: string, label: string): URL { + try { + return new URLConstructor(value); + } catch { + localIntegrationConfigurationError(`${label} must be a valid URL`); + } +} + +function assertFixedHttpsUrl(value: string, label: string): string { + const parsed = parseUrl(value, label); + if ( + urlValue(urlProtocol, parsed) !== "https:" || + urlValue(urlUsername, parsed) !== "" || + urlValue(urlPassword, parsed) !== "" || + urlValue(urlHash, parsed) !== "" + ) { + localIntegrationConfigurationError(`${label} must be a fixed HTTPS URL without credentials`); + } + return value; +} + +function normalizedConnectorPrefix(name: string): string { + let prefix = ""; + for (let index = 0; index < name.length; index++) { + const code = name.charCodeAt(index); + if (code >= 97 && code <= 122) prefix += String.fromCharCode(code - 32); + else if (code >= 65 && code <= 90 || code >= 48 && code <= 57) prefix += name[index]; + else prefix += "_"; + } + return prefix; +} + +function declaredFallback(connector: IntegrationConfig, name: string): string | undefined { + for (let index = 0; index < (connector.envVars?.length ?? 0); index++) { + const envVar = connector.envVars?.[index]; + if (envVar?.name !== name) continue; + if (envVar.default !== undefined) return envVar.default; + return envVar.required === false ? "" : undefined; + } + return undefined; +} + +/** Build a serializable, value-free credential plan from trusted catalog metadata. */ +export function createLocalCredentialAuthPlan( + connector: IntegrationConfig, +): LocalCredentialAuthPlan { + const auth = connector.auth; + if (connector.name === "salesforce") { + return freeze({ + kind: "salesforce-service-account", + connectorName: connector.name, + clientIdName: "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID", + clientSecretName: "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET", + loginUrlName: "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL", + requiredEnvironmentVariables: freeze([ + "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID", + "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET", + "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL", + ]), + }); + } + + if (auth.type === "api-key") { + if (auth.queryParamName) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" uses unsupported query credentials`, + ); + } + if (!auth.keyName) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" is missing its API-key name`, + ); + } + const additionalHeaders = freeze({ ...auth.additionalHeaders }); + const required = [auth.keyName, ...Object.values(additionalHeaders)]; + return freeze({ + kind: "api-key", + connectorName: connector.name, + keyName: auth.keyName, + headerName: auth.headerName ?? "Authorization", + headerPrefix: auth.headerPrefix, + additionalHeaders, + requiredEnvironmentVariables: freeze(required), + }); + } + + if (auth.type === "basic") { + if (!auth.usernameKey || !auth.passwordKey) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" is missing Basic credential names`, + ); + } + return freeze({ + kind: "basic", + connectorName: connector.name, + usernameName: auth.usernameKey, + passwordName: auth.passwordKey, + passwordFallback: declaredFallback(connector, auth.passwordKey), + requiredEnvironmentVariables: freeze([auth.usernameKey, auth.passwordKey]), + }); + } + + if (auth.type === "oauth2" && auth.grantType === "client_credentials") { + if (!auth.tokenUrl || auth.tokenUrl.includes("{{")) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" requires a fixed token URL`, + ); + } + const prefix = normalizedConnectorPrefix(connector.name); + const clientIdName = `${prefix}_CLIENT_ID`; + const clientSecretName = `${prefix}_CLIENT_SECRET`; + const requestBodyAuth = auth.tokenAuthMethod === "post" || + auth.tokenAuthMethod === "request_body"; + return freeze({ + kind: "client-credentials", + connectorName: connector.name, + clientIdName, + clientSecretName, + scopes: freeze([...(auth.scopes ?? [])]), + tokenAuthMethod: requestBodyAuth ? "request-body" : "basic", + tokenUrl: assertFixedHttpsUrl( + auth.tokenUrl, + `Local integration "${connector.name}" token URL`, + ), + requiredEnvironmentVariables: freeze([clientIdName, clientSecretName]), + }); + } + + localIntegrationConfigurationError( + `Local integration "${connector.name}" uses unsupported authorization-code credentials`, + ); +} + +function base64(value: string): string { + const bytes = apply(textEncoderEncode, textEncoder, [value]) as Uint8Array; + const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + let result = ""; + for (let index = 0; index < bytes.length; index += 3) { + const first = bytes[index] ?? 0; + const secondPresent = index + 1 < bytes.length; + const thirdPresent = index + 2 < bytes.length; + const second = bytes[index + 1] ?? 0; + const third = bytes[index + 2] ?? 0; + result += alphabet[first >> 2]; + result += alphabet[((first & 3) << 4) | (second >> 4)]; + result += secondPresent ? alphabet[((second & 15) << 2) | (third >> 6)] : "="; + result += thirdPresent ? alphabet[third & 63] : "="; + } + return result; +} + +function formEntry(name: string, value: string): string { + return `${encodeUriComponent(name)}=${encodeUriComponent(value)}`; +} + +async function readCredential( + provider: LocalIntegrationCredentialProvider, + connectorName: string, + name: string, +): Promise { + let value: unknown; + try { + value = await apply(provider, undefined, [name]); + } catch { + throw LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE.create({ + detail: `The credential provider could not read ${name} for ${connectorName}`, + }); + } + if (typeof value !== "string") return undefined; + const trimmed = stringCall(stringTrim, value); + if (trimmed.length === 0 || value.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH) { + return undefined; + } + return value; +} + +async function readCredentials( + plan: LocalCredentialAuthPlan, + provider: LocalIntegrationCredentialProvider, +): Promise> { + const values: Record = Object.create(null); + const missing: string[] = []; + for (let index = 0; index < plan.requiredEnvironmentVariables.length; index++) { + const name = plan.requiredEnvironmentVariables[index]!; + const value = await readCredential(provider, plan.connectorName, name); + if (value === undefined) missing.push(name); + else values[name] = value; + } + if ( + plan.kind === "basic" && values[plan.passwordName] === undefined && + plan.passwordFallback !== undefined + ) { + values[plan.passwordName] = plan.passwordFallback; + const missingIndex = missing.indexOf(plan.passwordName); + if (missingIndex >= 0) missing.splice(missingIndex, 1); + } + if (missing.length > 0) { + throw LOCAL_INTEGRATION_CREDENTIALS_MISSING.create({ + detail: `Set local integration credential variables: ${missing.join(", ")}`, + }); + } + return values; +} + +function normalizeSalesforceLoginUrl(value: string): string { + const parsed = parseUrl(value, "Salesforce service-account login URL"); + const protocol = urlValue(urlProtocol, parsed); + const hostname = stringCall(stringToLowerCase, urlValue(urlHostname, parsed)); + const pathname = urlValue(urlPathname, parsed); + if ( + protocol !== "https:" || urlValue(urlPort, parsed) !== "" || + urlValue(urlUsername, parsed) !== "" || urlValue(urlPassword, parsed) !== "" || + urlValue(urlSearch, parsed) !== "" || urlValue(urlHash, parsed) !== "" || + (pathname !== "" && pathname !== "/") || + (!stringEndsWithValue(hostname, ".my.salesforce.com") && + !stringEndsWithValue(hostname, ".my-salesforce.com")) + ) { + localIntegrationConfigurationError( + "Salesforce service-account login URL must be an HTTPS Salesforce My Domain origin", + ); + } + return `https://${hostname}`; +} + +/** Resolve short-lived secret values for a previously validated auth plan. */ +export async function resolveLocalCredentialAuth( + plan: LocalCredentialAuthPlan, + provider: LocalIntegrationCredentialProvider, +): Promise { + const values = await readCredentials(plan, provider); + + if (plan.kind === "api-key") { + const key = values[plan.keyName]!; + const headers: Record = Object.create(null); + headers[plan.headerName] = plan.headerPrefix ? `${plan.headerPrefix} ${key}` : key; + for (const [headerName, environmentName] of Object.entries(plan.additionalHeaders)) { + headers[headerName] = values[environmentName]!; + } + return freeze({ kind: "headers", connectorName: plan.connectorName, headers: freeze(headers) }); + } + + if (plan.kind === "basic") { + const credential = `${values[plan.usernameName]!}:${values[plan.passwordName]!}`; + return freeze({ + kind: "headers", + connectorName: plan.connectorName, + headers: freeze({ Authorization: `Basic ${base64(credential)}` }), + }); + } + + if (plan.kind === "client-credentials") { + const clientId = values[plan.clientIdName]!; + const clientSecret = values[plan.clientSecretName]!; + const body = [formEntry("grant_type", "client_credentials")]; + if (plan.scopes.length > 0) body.push(formEntry("scope", plan.scopes.join(" "))); + const headers: Record = { + Accept: "application/json", + "Content-Type": "application/x-www-form-urlencoded", + }; + if (plan.tokenAuthMethod === "request-body") { + body.push(formEntry("client_id", clientId)); + body.push(formEntry("client_secret", clientSecret)); + } else { + headers.Authorization = `Basic ${base64(`${clientId}:${clientSecret}`)}`; + } + return freeze({ + kind: "token-request", + connectorName: plan.connectorName, + mode: "client-credentials", + url: plan.tokenUrl, + headers: freeze(headers), + body: body.join("&"), + }); + } + + const loginOrigin = normalizeSalesforceLoginUrl(values[plan.loginUrlName]!); + return freeze({ + kind: "token-request", + connectorName: plan.connectorName, + mode: "salesforce-service-account", + url: `${loginOrigin}/services/oauth2/token`, + headers: freeze({ + Accept: "application/json", + "Content-Type": "application/x-www-form-urlencoded", + }), + body: [ + formEntry("grant_type", "client_credentials"), + formEntry("client_id", values[plan.clientIdName]!), + formEntry("client_secret", values[plan.clientSecretName]!), + ].join("&"), + }); +} diff --git a/src/integrations/local-integration-errors.ts b/src/integrations/local-integration-errors.ts new file mode 100644 index 0000000000..92b31421cc --- /dev/null +++ b/src/integrations/local-integration-errors.ts @@ -0,0 +1,29 @@ +import { defineError } from "#veryfront/errors"; + +export const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ + slug: "local-integration-config-invalid", + category: "CONFIG", + status: 400, + title: "Invalid local integration configuration", + suggestion: "Use exact catalog tool IDs and supported local credential and endpoint contracts", +}); + +export const LOCAL_INTEGRATION_CREDENTIALS_MISSING = defineError({ + slug: "local-integration-credentials-missing", + category: "CONFIG", + status: 400, + title: "Local integration credentials are missing", + suggestion: "Set the named environment variables or configure a credential provider", +}); + +export const LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE = defineError({ + slug: "local-integration-credential-unavailable", + category: "RUNTIME", + status: 503, + title: "Local integration credential is unavailable", + suggestion: "Check the local credential provider and retry", +}); + +export function localIntegrationConfigurationError(detail: string): never { + throw LOCAL_INTEGRATION_CONFIG_INVALID.create({ detail }); +} diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index f972857148..7993fb84fb 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -76,6 +76,23 @@ describe("createLocalIntegrationToolSource", () => { ]); }); + it("validates configured credential names before exposing tools", async () => { + const calls: string[] = []; + const source = createLocalIntegrationToolSource({ + tools: ["sendcloud__list_shipments"], + credentialProvider: (name) => { + calls.push(name); + return name === "SENDCLOUD_PUBLIC_KEY" ? "public-key" : undefined; + }, + }); + + const error = await assertRejects(() => source.listTools(), VeryfrontError); + assertEquals(calls, ["SENDCLOUD_PUBLIC_KEY", "SENDCLOUD_SECRET_KEY"]); + assertEquals(error.slug, "local-integration-credentials-missing"); + assertEquals(error.message.includes("SENDCLOUD_SECRET_KEY"), true); + assertEquals(error.message.includes("public-key"), false); + }); + it("fails closed for malformed, unknown, duplicate, and unsupported tools", async () => { const fixtures = [ { tool: "vercel", detail: "canonical" }, diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 2d43eee11f..9c4cbfd79c 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -1,24 +1,22 @@ import { getEnvironmentConfig } from "#veryfront/config/environment-config.ts"; -import { defineError } from "#veryfront/errors"; import type { JsonSchema } from "#veryfront/extensions/schema/index.ts"; +import { getEnv } from "#veryfront/platform/compat/process/env.ts"; import type { RemoteToolSource, ToolDefinition, ToolExecutionContext, } from "#veryfront/tool/types.ts"; import { connectors } from "./_data.ts"; +import { + createLocalCredentialAuthPlan, + type LocalCredentialAuthPlan, + resolveLocalCredentialAuth, +} from "./local-credential-auth.ts"; +import { localIntegrationConfigurationError } from "./local-integration-errors.ts"; import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; import { parseIntegrationToolIdentity } from "./source-policy.ts"; import type { IntegrationConfig, IntegrationToolMeta } from "./schema.ts"; -const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ - slug: "local-integration-config-invalid", - category: "CONFIG", - status: 400, - title: "Invalid local integration configuration", - suggestion: "Use exact catalog tool IDs and supported local credential and endpoint contracts", -}); - /** Resolve one local integration credential by its canonical environment-variable name. */ export type LocalIntegrationCredentialProvider = ( environmentVariableName: string, @@ -35,6 +33,7 @@ export interface LocalIntegrationToolSourceOptions { type IntegrationEndpoint = NonNullable; interface AdmittedLocalIntegrationTool { + readonly authPlan: LocalCredentialAuthPlan; readonly connector: IntegrationConfig; readonly endpoint: IntegrationEndpoint; readonly tool: IntegrationToolMeta & { id: string }; @@ -42,7 +41,7 @@ interface AdmittedLocalIntegrationTool { } function configurationError(detail: string): never { - throw LOCAL_INTEGRATION_CONFIG_INVALID.create({ detail }); + return localIntegrationConfigurationError(detail); } function readOwnDataProperty( @@ -294,6 +293,7 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { assertSupportedEndpoint(connector, tool.endpoint, canonicalToolId); assertSupportedAuth(connector, tool.endpoint); return Object.freeze({ + authPlan: createLocalCredentialAuthPlan(connector), connector, endpoint: tool.endpoint, tool, @@ -316,6 +316,7 @@ export function createLocalIntegrationToolSource( ): RemoteToolSource { const snapshot = snapshotOptions(options); const admitted = new Map(); + const credentialProvider = snapshot.credentialProvider ?? getEnv; for (const toolId of snapshot.tools) { if (admitted.has(toolId)) { @@ -328,6 +329,13 @@ export function createLocalIntegrationToolSource( id: "veryfront-local-integrations", async listTools(): Promise { assertLocalRuntime(); + const validatedConnectors = new Set(); + for (const toolId of snapshot.tools) { + const tool = admitted.get(toolId)!; + if (validatedConnectors.has(tool.connector.name)) continue; + await resolveLocalCredentialAuth(tool.authPlan, credentialProvider); + validatedConnectors.add(tool.connector.name); + } return snapshot.tools.map((toolId) => admitted.get(toolId)!.definition); }, async executeTool( From 11b567dcc257e752119912d944b5bdf22923d1c1 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:14:37 +0200 Subject: [PATCH 05/25] Keep local integration HTTP execution inside a bounded egress contract Catalog metadata now constructs exact-origin REST requests without exposing provider responses or transport failures. The executor rejects unknown or mistyped arguments before transport, applies defaults deterministically, rejects redirects, shares the guarded egress boundary, and bounds JSON response reads. Constraint: Local integration credentials and provider response bodies must never enter errors, URLs outside the admitted origin, or unbounded memory. Rejected: Reuse ordinary fetch directly | it would bypass redirect-hop and private-address enforcement. Confidence: high Scope-risk: moderate Directive: Keep transport injection internal and preserve exact-origin authorization on every network hop. Tested: 19 focused Deno steps; deno check; deno lint; deno fmt; anti-slop; diff and line-width checks. Not-tested: Live third-party provider responses and token endpoints remain for the next slice. --- .../local-endpoint-executor.test.ts | 323 +++++++++++ src/integrations/local-endpoint-executor.ts | 548 ++++++++++++++++++ src/integrations/local-integration-errors.ts | 24 + src/integrations/local-tool-source.ts | 5 +- 4 files changed, 898 insertions(+), 2 deletions(-) create mode 100644 src/integrations/local-endpoint-executor.test.ts create mode 100644 src/integrations/local-endpoint-executor.ts diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts new file mode 100644 index 0000000000..d6d9205afd --- /dev/null +++ b/src/integrations/local-endpoint-executor.test.ts @@ -0,0 +1,323 @@ +import "#veryfront/schemas/_test-setup.ts"; +import { VeryfrontError } from "#veryfront/errors"; +import { + assert, + assertEquals, + assertInstanceOf, + assertRejects, +} from "#veryfront/testing/assert.ts"; +import { describe, it } from "#veryfront/testing/bdd.ts"; +import type { IntegrationToolMeta } from "./schema.ts"; +import { + executeLocalIntegrationEndpoint, + type LocalIntegrationEndpointTransport, +} from "./local-endpoint-executor.ts"; + +type IntegrationEndpoint = NonNullable; + +const SECRET = "LOCAL_ENDPOINT_SECRET_MUST_NOT_LEAK"; + +function endpoint(value: IntegrationEndpoint): IntegrationEndpoint { + return value; +} + +describe("local integration endpoint executor", () => { + it( + "builds a bounded REST request from catalog path, query, header, and body fields", + async () => { + const requests: Array<{ url: string; init: RequestInit; allowedOrigin: string }> = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + requests.push({ + url: request.url.href, + init: request.init, + allowedOrigin: request.allowedOrigin, + }); + return Promise.resolve(Response.json({ data: { items: [{ id: "item-1" }] } })); + }; + + const result = await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "POST", + url: "https://api.example.test/v1/items/{itemId}", + params: { + itemId: { + type: "string", + in: "path", + description: "Item ID", + required: true, + }, + limit: { + type: "number", + in: "query", + description: "Page size", + default: 25, + }, + tags: { + type: "string[]", + in: "query", + description: "Tags", + }, + account: { + type: "string", + in: "header", + headerName: "X-Account-ID", + description: "Account", + required: true, + }, + }, + body: { + count: { + type: "number", + description: "Count", + required: true, + }, + note: { + type: "string", + description: "Note", + default: "catalog-default", + }, + }, + response: { transform: "data.items" }, + }), + args: { + itemId: "a/b", + tags: ["red blue", "blue"], + account: "acct-1", + count: 2, + }, + authHeaders: { Authorization: `Bearer ${SECRET}` }, + allowedOrigin: "https://api.example.test", + transport, + }); + + assertEquals(result, [{ id: "item-1" }]); + assertEquals(requests.length, 1); + assertEquals( + requests[0]?.url, + "https://api.example.test/v1/items/a%2Fb?limit=25&tags=red+blue&tags=blue", + ); + assertEquals(requests[0]?.allowedOrigin, "https://api.example.test"); + assertEquals(requests[0]?.init.method, "POST"); + assertEquals(requests[0]?.init.redirect, "error"); + assertEquals( + new Headers(requests[0]?.init.headers).get("authorization"), + `Bearer ${SECRET}`, + ); + assertEquals(new Headers(requests[0]?.init.headers).get("x-account-id"), "acct-1"); + assertEquals( + new Headers(requests[0]?.init.headers).get("content-type"), + "application/json", + ); + assertEquals(requests[0]?.init.body, '{"count":2,"note":"catalog-default"}'); + }, + ); + + it("supports passthrough JSON bodies and Microsoft Graph query formatting", async () => { + let requestBody: BodyInit | null | undefined; + let requestUrl = ""; + const result = await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "POST", + url: "https://api.example.test/search", + params: { + search: { + type: "string", + in: "query", + queryName: "$search", + queryValueFormat: "microsoft-graph-search", + description: "Search query", + required: true, + }, + }, + body: { + payload: { + type: "object", + description: "Request payload", + required: true, + }, + }, + bodyMode: "passthrough", + }), + args: { + search: "from:ada@example.test", + payload: { nested: [true, 3] }, + }, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport: (request) => { + requestBody = request.init.body; + requestUrl = request.url.href; + return Promise.resolve(Response.json({ ok: true })); + }, + }); + + assertEquals( + requestUrl, + "https://api.example.test/search?%24search=%22from%3Aada%40example.test%22", + ); + assertEquals(requestBody, '{"nested":[true,3]}'); + assertEquals(result, { ok: true }); + }); + + it("rejects invalid arguments before any transport call", async () => { + const requiredEndpoint = endpoint({ + method: "GET", + url: "https://api.example.test/items/{id}", + params: { + id: { + type: "string", + in: "path", + description: "Item ID", + required: true, + }, + active: { + type: "boolean", + in: "query", + description: "Active", + }, + }, + }); + let transportCalls = 0; + const transport: LocalIntegrationEndpointTransport = () => { + transportCalls += 1; + return Promise.resolve(Response.json({ ok: true })); + }; + + for ( + const args of [ + {}, + { id: 42 }, + { id: "item", active: "true" }, + { id: "item", unknown: true }, + ] + ) { + const error = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: requiredEndpoint, + args, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport, + }), + VeryfrontError, + ); + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + } + + assertEquals(transportCalls, 0); + }); + + it("uses an exact-origin, redirect-rejecting transport contract", async () => { + let authorized = false; + await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/items", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport: (request) => { + assertEquals(request.url.origin, request.allowedOrigin); + assertEquals(request.init.redirect, "error"); + assert(request.init.signal instanceof AbortSignal); + authorized = true; + return Promise.resolve(Response.json([])); + }, + }); + assert(authorized); + }); + + it("bounds responses and never exposes provider bodies, URLs, headers, or causes", async () => { + const fixtures = [ + () => new Response(SECRET, { status: 500 }), + () => new Response(`{"secret":"${SECRET}"`, { status: 200 }), + () => + new Response("{}", { + headers: { "content-length": String(4 * 1024 * 1024 + 1) }, + }), + ]; + + for (const response of fixtures) { + const error = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: `https://api.example.test/items?credential=${SECRET}`, + }), + args: {}, + authHeaders: { Authorization: `Bearer ${SECRET}` }, + allowedOrigin: "https://api.example.test", + transport: () => Promise.resolve(response()), + }), + VeryfrontError, + ); + assertInstanceOf(error, VeryfrontError); + assert( + error.slug === "local-integration-request-failed" || + error.slug === "local-integration-response-invalid", + ); + assertEquals(error.message.includes(SECRET), false); + assertEquals(error.cause, undefined); + } + }); + + it("enforces its deadline and caller cancellation without leaking abort reasons", async () => { + const abortController = new AbortController(); + const pending = executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/slow", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + signal: abortController.signal, + timeoutMs: 100, + transport: (request) => + new Promise((_resolve, reject) => { + request.init.signal?.addEventListener( + "abort", + () => reject(request.init.signal?.reason), + { once: true }, + ); + }), + }); + abortController.abort(new Error(SECRET)); + + const error = await assertRejects(() => pending, VeryfrontError); + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-failed"); + assertEquals(error.message.includes(SECRET), false); + assertEquals(error.cause, undefined); + + const timeoutError = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/slow", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + timeoutMs: 5, + transport: (request) => + new Promise((_resolve, reject) => { + request.init.signal?.addEventListener( + "abort", + () => reject(request.init.signal?.reason), + { once: true }, + ); + }), + }), + VeryfrontError, + ); + assertInstanceOf(timeoutError, VeryfrontError); + assertEquals(timeoutError.slug, "local-integration-request-failed"); + assertEquals(timeoutError.cause, undefined); + }); +}); diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts new file mode 100644 index 0000000000..6247df9340 --- /dev/null +++ b/src/integrations/local-endpoint-executor.ts @@ -0,0 +1,548 @@ +import { snapshotBoundedJsonValue } from "#veryfront/schemas/json-value.ts"; +import { guardedEgressFetch } from "#veryfront/security/sandbox/worker-egress-guard.ts"; +import { readResponseTextPrefix } from "#veryfront/utils/response-body.ts"; +import { + LOCAL_INTEGRATION_REQUEST_FAILED, + LOCAL_INTEGRATION_REQUEST_INVALID, + LOCAL_INTEGRATION_RESPONSE_INVALID, +} from "./local-integration-errors.ts"; +import { + INTEGRATION_REQUEST_TIMEOUT_MS, + MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES, +} from "./limits.ts"; +import type { IntegrationToolMeta } from "./schema.ts"; + +type IntegrationEndpoint = NonNullable; +type IntegrationEndpointParam = NonNullable[string]; +type IntegrationEndpointBodyField = NonNullable[string]; + +const abortControllerAbort = AbortController.prototype.abort; +const AbortControllerConstructor = AbortController; +const abortSignalAborted = Object.getOwnPropertyDescriptor( + AbortSignal.prototype, + "aborted", +)?.get; +const abortSignalReason = Object.getOwnPropertyDescriptor( + AbortSignal.prototype, + "reason", +)?.get; +const addEventListener = EventTarget.prototype.addEventListener; +const apply = Reflect.apply; +const arrayIsArray = Array.isArray; +const clearTimeoutIntrinsic = clearTimeout; +const DOMExceptionConstructor = DOMException; +const encodeUriComponent = encodeURIComponent; +const freeze = Object.freeze; +const getOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor; +const HeadersConstructor = Headers; +const headersGet = Headers.prototype.get; +const headersSet = Headers.prototype.set; +const jsonParse = JSON.parse; +const jsonStringify = JSON.stringify; +const numberIsFinite = Number.isFinite; +const numberIsSafeInteger = Number.isSafeInteger; +const objectCreate = Object.create; +const objectDefineProperty = Object.defineProperty; +const objectKeys = Object.keys; +const removeEventListener = EventTarget.prototype.removeEventListener; +const responseBody = Object.getOwnPropertyDescriptor(Response.prototype, "body")?.get; +const responseHeaders = Object.getOwnPropertyDescriptor(Response.prototype, "headers")?.get; +const responseStatus = Object.getOwnPropertyDescriptor(Response.prototype, "status")?.get; +const setTimeoutIntrinsic = setTimeout; +const StringConstructor = String; +const stringCharCodeAt = String.prototype.charCodeAt; +const stringIncludes = String.prototype.includes; +const stringReplaceAll = String.prototype.replaceAll; +const stringSlice = String.prototype.slice; +const textEncoder = new TextEncoder(); +const textEncoderEncode = TextEncoder.prototype.encode; +const URLConstructor = URL; +const urlOrigin = Object.getOwnPropertyDescriptor(URL.prototype, "origin")?.get; +const urlSearchParams = Object.getOwnPropertyDescriptor(URL.prototype, "searchParams")?.get; +const urlSearchParamsAppend = URLSearchParams.prototype.append; +const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype); +const typedArrayByteLength = Object.getOwnPropertyDescriptor( + typedArrayPrototype, + "byteLength", +)?.get; + +if ( + typeof abortSignalAborted !== "function" || + typeof abortSignalReason !== "function" || + typeof responseBody !== "function" || + typeof responseHeaders !== "function" || + typeof responseStatus !== "function" || + typeof typedArrayByteLength !== "function" || + typeof urlOrigin !== "function" || + typeof urlSearchParams !== "function" +) { + throw new TypeError("Local integration HTTP primitives are unavailable"); +} + +/** A fully constructed request admitted to the local integration transport. */ +export interface LocalIntegrationEndpointTransportRequest { + readonly url: URL; + readonly init: RequestInit; + readonly allowedOrigin: string; +} + +/** Internal transport seam used to verify request construction without network access. */ +export type LocalIntegrationEndpointTransport = ( + request: LocalIntegrationEndpointTransportRequest, +) => Promise; + +export interface ExecuteLocalIntegrationEndpointOptions { + readonly endpoint: IntegrationEndpoint; + readonly args: Record; + readonly authHeaders: Readonly>; + readonly allowedOrigin: string; + readonly signal?: AbortSignal; + /** Internal test seam. Production callers use the standard integration deadline. */ + readonly timeoutMs?: number; + /** Internal test seam. Production callers use the guarded egress transport. */ + readonly transport?: LocalIntegrationEndpointTransport; +} + +interface RequestSignalLease { + readonly signal: AbortSignal; + release(): void; +} + +function requestInvalid(detail: string): never { + throw LOCAL_INTEGRATION_REQUEST_INVALID.create({ detail }); +} + +function requestFailed(): never { + throw LOCAL_INTEGRATION_REQUEST_FAILED.create(); +} + +function responseInvalid(): never { + throw LOCAL_INTEGRATION_RESPONSE_INVALID.create(); +} + +function callStringBoolean( + operation: (this: string, searchString: string, position?: number) => boolean, + value: string, + searchString: string, +): boolean { + return apply(operation, value, [searchString]); +} + +function replaceAll(value: string, search: string, replacement: string): string { + return apply(stringReplaceAll, value, [search, replacement]); +} + +function urlValue(getter: ((this: URL) => string) | undefined, value: URL): string { + if (!getter) requestFailed(); + return apply(getter, value, []); +} + +function signalValue( + getter: ((this: AbortSignal) => T) | undefined, + signal: AbortSignal, +): T { + if (!getter) requestFailed(); + return apply(getter, signal, []); +} + +function responseStatusValue(response: Response): number { + if (!responseStatus) requestFailed(); + return apply(responseStatus, response, []) as number; +} + +function responseBodyValue(response: Response): ReadableStream | null { + if (!responseBody) responseInvalid(); + return apply(responseBody, response, []) as ReadableStream | null; +} + +function responseHeadersValue(response: Response): Headers { + if (!responseHeaders) responseInvalid(); + return apply(responseHeaders, response, []) as Headers; +} + +function charCodeAt(value: string, index: number): number { + return apply(stringCharCodeAt, value, [index]); +} + +function slice(value: string, start: number, end?: number): string { + return end === undefined + ? apply(stringSlice, value, [start]) + : apply(stringSlice, value, [start, end]); +} + +function ownValue( + record: Readonly>, + key: string, +): { present: boolean; value: unknown } { + const descriptor = getOwnPropertyDescriptor(record, key); + if (!descriptor) return { present: false, value: undefined }; + if (!("value" in descriptor)) requestInvalid(`Local integration argument "${key}" is invalid`); + return { present: true, value: descriptor.value }; +} + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !arrayIsArray(value); +} + +function valueMatchesType( + value: unknown, + type: IntegrationEndpointParam["type"] | IntegrationEndpointBodyField["type"], +): boolean { + if (type === "string") return typeof value === "string"; + if (type === "number") return typeof value === "number" && numberIsFinite(value); + if (type === "boolean") return typeof value === "boolean"; + if (type === "object") return isRecord(value); + if (type === "array") return arrayIsArray(value); + if (type === "string[]") { + if (!arrayIsArray(value)) return false; + for (let index = 0; index < value.length; index++) { + if (typeof value[index] !== "string") return false; + } + return true; + } + return false; +} + +function fieldValue( + args: Record, + name: string, + field: IntegrationEndpointParam | IntegrationEndpointBodyField, +): { present: boolean; value: unknown } { + const supplied = ownValue(args, name); + const value = supplied.present ? supplied.value : field.default; + const present = supplied.present || field.default !== undefined; + if (!present) { + if (field.required === true) { + requestInvalid(`Local integration argument "${name}" is required`); + } + return { present: false, value: undefined }; + } + if (!valueMatchesType(value, field.type)) { + requestInvalid(`Local integration argument "${name}" must have type "${field.type}"`); + } + return { present: true, value }; +} + +function scalarString(value: unknown): string { + if (typeof value === "string") return value; + if (typeof value === "number" || typeof value === "boolean") { + return StringConstructor(value); + } + requestInvalid("Local integration path, query, and header arguments must be scalar values"); +} + +function appendQueryValue( + searchParams: URLSearchParams, + name: string, + value: unknown, + field: IntegrationEndpointParam, +): void { + const append = (item: string): void => { + const formatted = field.queryValueFormat === "microsoft-graph-search" + ? `"${replaceAll(item, '"', '\\"')}"` + : item; + apply(urlSearchParamsAppend, searchParams, [field.queryName ?? name, formatted]); + }; + if (arrayIsArray(value)) { + for (let index = 0; index < value.length; index++) append(value[index]); + return; + } + append(scalarString(value)); +} + +function setHeader(headers: Headers, name: string, value: string): void { + try { + apply(headersSet, headers, [name, value]); + } catch { + requestInvalid("Local integration header input is invalid"); + } +} + +function snapshotArguments(args: Record): Record { + const snapshot = snapshotBoundedJsonValue(args); + if (!snapshot.success || !isRecord(snapshot.value)) { + requestInvalid("Local integration arguments must be a bounded JSON object"); + } + return snapshot.value; +} + +function assertKnownArguments( + args: Record, + endpoint: IntegrationEndpoint, +): void { + const paramNames = objectKeys(endpoint.params ?? {}); + const bodyNames = objectKeys(endpoint.body ?? {}); + for (const name of objectKeys(args)) { + let known = false; + for (let index = 0; index < paramNames.length; index++) { + if (paramNames[index] === name) known = true; + } + for (let index = 0; index < bodyNames.length; index++) { + if (bodyNames[index] === name) known = true; + } + if (!known) requestInvalid(`Local integration argument "${name}" is not declared`); + } +} + +function serializeJson(value: unknown): string { + const snapshot = snapshotBoundedJsonValue(value); + if (!snapshot.success) requestInvalid("Local integration request body must be bounded JSON"); + try { + return jsonStringify(snapshot.value); + } catch { + requestInvalid("Local integration request body must be serializable JSON"); + } +} + +function buildRequest( + endpoint: IntegrationEndpoint, + args: Record, + authHeaders: Readonly>, + allowedOrigin: string, + signal: AbortSignal, +): LocalIntegrationEndpointTransportRequest { + assertKnownArguments(args, endpoint); + let endpointUrl = endpoint.url; + const headers = new HeadersConstructor(); + + for (const name of objectKeys(endpoint.params ?? {})) { + const field = endpoint.params?.[name]; + if (!field) continue; + const resolved = fieldValue(args, name, field); + if (!resolved.present) continue; + if (field.in === "path") { + endpointUrl = replaceAll( + endpointUrl, + `{${name}}`, + encodeUriComponent(scalarString(resolved.value)), + ); + } else if (field.in === "header") { + setHeader(headers, field.headerName ?? name, scalarString(resolved.value)); + } + } + + if (callStringBoolean(stringIncludes, endpointUrl, "{")) { + requestInvalid("Local integration endpoint contains an unresolved path parameter"); + } + + let url: URL; + try { + url = new URLConstructor(endpointUrl); + } catch { + requestInvalid("Local integration endpoint URL is invalid"); + } + if (urlValue(urlOrigin, url) !== allowedOrigin) { + requestInvalid("Local integration endpoint origin does not match its admitted origin"); + } + + if (!urlSearchParams) requestFailed(); + const searchParams = apply(urlSearchParams, url, []) as URLSearchParams; + for (const name of objectKeys(endpoint.params ?? {})) { + const field = endpoint.params?.[name]; + if (!field || field.in !== "query") continue; + const resolved = fieldValue(args, name, field); + if (resolved.present) appendQueryValue(searchParams, name, resolved.value, field); + } + + for (const name of objectKeys(authHeaders)) { + const value = ownValue(authHeaders, name); + if (!value.present || typeof value.value !== "string") { + requestInvalid("Local integration authorization headers are invalid"); + } + setHeader(headers, name, value.value); + } + + let body: string | undefined; + const bodyFields = objectKeys(endpoint.body ?? {}); + if (endpoint.bodyMode === "passthrough") { + if (bodyFields.length !== 1) { + requestInvalid("Local integration passthrough bodies require exactly one field"); + } + const name = bodyFields[0]!; + const field = endpoint.body?.[name]!; + const resolved = fieldValue(args, name, field); + if (resolved.present) body = serializeJson(resolved.value); + } else if (bodyFields.length > 0) { + const record = objectCreate(null) as Record; + for (let index = 0; index < bodyFields.length; index++) { + const name = bodyFields[index]!; + const field = endpoint.body?.[name]!; + const resolved = fieldValue(args, name, field); + if (resolved.present) { + objectDefineProperty(record, name, { + configurable: true, + enumerable: true, + value: resolved.value, + writable: true, + }); + } + } + body = serializeJson(record); + } + + if (body !== undefined) { + setHeader(headers, "Content-Type", endpoint.contentType ?? "application/json"); + } + + return freeze({ + url, + allowedOrigin, + init: freeze({ + method: endpoint.method, + headers, + body, + redirect: "error" as const, + signal, + }), + }); +} + +function createRequestSignal( + signal: AbortSignal | undefined, + timeoutMs: number, +): RequestSignalLease { + if (!numberIsSafeInteger(timeoutMs) || timeoutMs <= 0) { + requestInvalid("Local integration timeout must be a positive safe integer"); + } + const controller = new AbortControllerConstructor(); + const abort = (): void => { + const reason = signal ? signalValue(abortSignalReason, signal) : undefined; + apply(abortControllerAbort, controller, [reason]); + }; + if (signal && signalValue(abortSignalAborted, signal)) abort(); + else if (signal) apply(addEventListener, signal, ["abort", abort, { once: true }]); + + const timeoutId = setTimeoutIntrinsic(() => { + apply(abortControllerAbort, controller, [ + new DOMExceptionConstructor("Request timed out", "TimeoutError"), + ]); + }, timeoutMs); + + return freeze({ + signal: controller.signal, + release(): void { + clearTimeoutIntrinsic(timeoutId); + if (signal) apply(removeEventListener, signal, ["abort", abort]); + }, + }); +} + +const guardedTransport: LocalIntegrationEndpointTransport = async (request) => { + return await guardedEgressFetch(request.url, request.init, { + authorizeUrl(url): void { + if (urlValue(urlOrigin, url) !== request.allowedOrigin) { + throw LOCAL_INTEGRATION_REQUEST_FAILED.create(); + } + }, + }); +}; + +function contentLengthWithinLimit(response: Response): boolean { + const raw = apply(headersGet, responseHeadersValue(response), [ + "content-length", + ]) as string | null; + if (raw === null) return true; + if (raw.length === 0) return false; + let value = 0; + for (let index = 0; index < raw.length; index++) { + const code = charCodeAt(raw, index); + if (code < 48 || code > 57) return false; + value = value * 10 + code - 48; + if (!numberIsSafeInteger(value) || value > MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES) { + return false; + } + } + return true; +} + +function decodedByteLength(value: string): number { + const encoded = apply(textEncoderEncode, textEncoder, [value]) as Uint8Array; + if (!typedArrayByteLength) responseInvalid(); + return apply(typedArrayByteLength, encoded, []) as number; +} + +async function readResponseJson(response: Response, signal: AbortSignal): Promise { + if (!contentLengthWithinLimit(response)) responseInvalid(); + let text: string; + let truncated: boolean; + try { + ({ text, truncated } = await readResponseTextPrefix( + response, + MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES + 1, + signal, + { fatalUtf8: true }, + )); + } catch { + responseInvalid(); + } + if ( + truncated || + decodedByteLength(text) > MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES + ) { + responseInvalid(); + } + let parsed: unknown; + try { + parsed = jsonParse(text); + } catch { + responseInvalid(); + } + const snapshot = snapshotBoundedJsonValue(parsed); + if (!snapshot.success) responseInvalid(); + return snapshot.value; +} + +function transformResponse(value: unknown, transform: string | undefined): unknown { + if (transform === undefined || transform === "") return value; + let current = value; + let start = 0; + for (let index = 0; index <= transform.length; index++) { + if (index < transform.length && charCodeAt(transform, index) !== 46) continue; + const segment = slice(transform, start, index); + if (segment === "" || !isRecord(current)) responseInvalid(); + const next = ownValue(current, segment); + if (!next.present) responseInvalid(); + current = next.value; + start = index + 1; + } + return current; +} + +/** Execute one admitted catalog REST endpoint through a bounded guarded transport. */ +export async function executeLocalIntegrationEndpoint( + options: ExecuteLocalIntegrationEndpointOptions, +): Promise { + const args = snapshotArguments(options.args); + const signalLease = createRequestSignal( + options.signal, + options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, + ); + try { + const request = buildRequest( + options.endpoint, + args, + options.authHeaders, + options.allowedOrigin, + signalLease.signal, + ); + let response: Response; + try { + response = await (options.transport ?? guardedTransport)(request); + } catch { + requestFailed(); + } + const status = responseStatusValue(response); + if (status < 200 || status >= 300) { + try { + void responseBodyValue(response)?.cancel().catch(() => undefined); + } catch { + // Response cleanup is best effort and must not expose provider errors. + } + requestFailed(); + } + const value = await readResponseJson(response, signalLease.signal); + return transformResponse(value, options.endpoint.response?.transform); + } finally { + signalLease.release(); + } +} diff --git a/src/integrations/local-integration-errors.ts b/src/integrations/local-integration-errors.ts index 92b31421cc..8719fe87f3 100644 --- a/src/integrations/local-integration-errors.ts +++ b/src/integrations/local-integration-errors.ts @@ -24,6 +24,30 @@ export const LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE = defineError({ suggestion: "Check the local credential provider and retry", }); +export const LOCAL_INTEGRATION_REQUEST_INVALID = defineError({ + slug: "local-integration-request-invalid", + category: "BOUNDARY", + status: 400, + title: "Local integration request is invalid", + suggestion: "Pass only the documented tool arguments with their declared JSON types", +}); + +export const LOCAL_INTEGRATION_REQUEST_FAILED = defineError({ + slug: "local-integration-request-failed", + category: "RUNTIME", + status: 502, + title: "Local integration request failed", + suggestion: "Check the provider status and local integration configuration, then retry", +}); + +export const LOCAL_INTEGRATION_RESPONSE_INVALID = defineError({ + slug: "local-integration-response-invalid", + category: "RUNTIME", + status: 502, + title: "Local integration response is invalid", + suggestion: "Check the provider response contract and retry", +}); + export function localIntegrationConfigurationError(detail: string): never { throw LOCAL_INTEGRATION_CONFIG_INVALID.create({ detail }); } diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 9c4cbfd79c..371d3d763b 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -45,7 +45,7 @@ function configurationError(detail: string): never { } function readOwnDataProperty( - value: object, + value: LocalIntegrationToolSourceOptions | readonly unknown[], key: PropertyKey, ): { present: boolean; value: unknown } { const descriptor = Reflect.getOwnPropertyDescriptor(value, key); @@ -158,7 +158,8 @@ function assertSupportedAuth( if (auth.type === "api-key") { if (auth.queryParamName || endpoint.url.includes("{{auth.token}}")) { configurationError( - `Local integration "${connector.name}" uses query or URL credentials, which are unsupported`, + `Local integration "${connector.name}" uses query or URL credentials, ` + + "which are unsupported", ); } if (!auth.keyName) { From db2ddabdb2cb9c76526aad8733d6aa81591d5aa5 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:19:33 +0200 Subject: [PATCH 06/25] Make explicit local grants executable without a Veryfront account The catalog-backed source now resolves project credentials at call time, mints short-lived OAuth client credentials through the guarded transport, validates Salesforce My Domain instance origins, and executes only the admitted tool endpoint. Local materialization keeps the existing source-policy narrowing and leaves the hosted API bridge unchanged. Constraint: Salesforce service-account responses may supply an instance origin, but never an arbitrary provider URL or redirect target. Rejected: Cache access tokens in the source | it would lengthen secret lifetime and complicate rotation and invalidation. Confidence: high Scope-risk: moderate Directive: Keep the test transport seam internal; the public source accepts only exact tool grants and a name-only credential provider. Tested: 110 focused Deno steps covering local execution, source policy, and the unchanged remote API bridge; deno check, lint, fmt, anti-slop, diff and line-width checks. Not-tested: Live provider credentials and third-party availability. --- src/integrations/local-credential-auth.ts | 98 +++++++- src/integrations/local-endpoint-executor.ts | 94 +++++++- src/integrations/local-tool-source.test.ts | 248 +++++++++++++++++++- src/integrations/local-tool-source.ts | 84 ++++++- 4 files changed, 497 insertions(+), 27 deletions(-) diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index f6d5e85d5b..1d33cc3003 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -3,11 +3,17 @@ import type { IntegrationConfig } from "./schema.ts"; import { LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, LOCAL_INTEGRATION_CREDENTIALS_MISSING, + LOCAL_INTEGRATION_RESPONSE_INVALID, localIntegrationConfigurationError, } from "./local-integration-errors.ts"; +import { + executeLocalIntegrationJsonRequest, + type LocalIntegrationEndpointTransport, +} from "./local-endpoint-executor.ts"; import { MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH } from "./limits.ts"; const apply = Reflect.apply; +const arrayIsArray = Array.isArray; const encodeUriComponent = encodeURIComponent; const freeze = Object.freeze; const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; @@ -19,6 +25,7 @@ const textEncoderEncode = TextEncoder.prototype.encode; const URLConstructor = URL; const urlHash = getOwnPropertyDescriptor(URL.prototype, "hash")?.get; const urlHostname = getOwnPropertyDescriptor(URL.prototype, "hostname")?.get; +const urlOrigin = getOwnPropertyDescriptor(URL.prototype, "origin")?.get; const urlPassword = getOwnPropertyDescriptor(URL.prototype, "password")?.get; const urlPathname = getOwnPropertyDescriptor(URL.prototype, "pathname")?.get; const urlPort = getOwnPropertyDescriptor(URL.prototype, "port")?.get; @@ -87,6 +94,11 @@ export type ResolvedLocalCredentialAuth = | ResolvedLocalHeaderAuth | ResolvedLocalTokenRequest; +export interface ResolvedLocalExecutionAuth { + readonly headers: Readonly>; + readonly instanceOrigin?: string; +} + function stringCall( operation: (this: string, ...args: never[]) => string, value: string, @@ -307,8 +319,13 @@ async function readCredentials( return values; } -function normalizeSalesforceLoginUrl(value: string): string { - const parsed = parseUrl(value, "Salesforce service-account login URL"); +function parseSalesforceOrigin(value: string): string | undefined { + let parsed: URL; + try { + parsed = new URLConstructor(value); + } catch { + return undefined; + } const protocol = urlValue(urlProtocol, parsed); const hostname = stringCall(stringToLowerCase, urlValue(urlHostname, parsed)); const pathname = urlValue(urlPathname, parsed); @@ -320,11 +337,48 @@ function normalizeSalesforceLoginUrl(value: string): string { (!stringEndsWithValue(hostname, ".my.salesforce.com") && !stringEndsWithValue(hostname, ".my-salesforce.com")) ) { + return undefined; + } + return `https://${hostname}`; +} + +function normalizeSalesforceLoginUrl(value: string): string { + const origin = parseSalesforceOrigin(value); + if (!origin) { localIntegrationConfigurationError( "Salesforce service-account login URL must be an HTTPS Salesforce My Domain origin", ); } - return `https://${hostname}`; + return origin; +} + +function tokenResponseInvalid(): never { + throw LOCAL_INTEGRATION_RESPONSE_INVALID.create(); +} + +function tokenResponseString( + value: Record, + key: string, +): string { + const descriptor = getOwnPropertyDescriptor(value, key); + if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "string") { + tokenResponseInvalid(); + } + const result = descriptor.value; + if ( + stringCall(stringTrim, result).length === 0 || + result.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH + ) { + tokenResponseInvalid(); + } + return result; +} + +function tokenResponseRecord(value: unknown): Record { + if (typeof value !== "object" || value === null || arrayIsArray(value)) { + tokenResponseInvalid(); + } + return value as Record; } /** Resolve short-lived secret values for a previously validated auth plan. */ @@ -395,3 +449,41 @@ export async function resolveLocalCredentialAuth( ].join("&"), }); } + +/** Mint a short-lived bearer credential from a previously resolved local auth request. */ +export async function mintLocalCredentialAuth( + resolved: ResolvedLocalCredentialAuth, + signal?: AbortSignal, + transport?: LocalIntegrationEndpointTransport, +): Promise { + if (resolved.kind === "headers") { + return freeze({ headers: resolved.headers }); + } + + const tokenUrl = parseUrl(resolved.url, "Local integration token URL"); + const tokenOrigin = urlValue(urlOrigin, tokenUrl); + const response = tokenResponseRecord( + await executeLocalIntegrationJsonRequest({ + url: resolved.url, + method: "POST", + headers: resolved.headers, + body: resolved.body, + allowedOrigin: tokenOrigin, + signal, + transport, + }), + ); + const accessToken = tokenResponseString(response, "access_token"); + const tokenType = stringCall(stringToLowerCase, tokenResponseString(response, "token_type")); + if (tokenType !== "bearer") tokenResponseInvalid(); + + const headers = freeze({ Authorization: `Bearer ${accessToken}` }); + if (resolved.mode === "client-credentials") return freeze({ headers }); + + return freeze({ + headers, + instanceOrigin: parseSalesforceOrigin( + tokenResponseString(response, "instance_url"), + ) ?? tokenResponseInvalid(), + }); +} diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 6247df9340..7549160929 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -103,6 +103,17 @@ export interface ExecuteLocalIntegrationEndpointOptions { readonly transport?: LocalIntegrationEndpointTransport; } +export interface ExecuteLocalIntegrationJsonRequestOptions { + readonly url: string; + readonly method: "POST"; + readonly headers: Readonly>; + readonly body: string; + readonly allowedOrigin: string; + readonly signal?: AbortSignal; + readonly timeoutMs?: number; + readonly transport?: LocalIntegrationEndpointTransport; +} + interface RequestSignalLease { readonly signal: AbortSignal; release(): void; @@ -492,6 +503,29 @@ async function readResponseJson(response: Response, signal: AbortSignal): Promis return snapshot.value; } +async function executeTransportRequest( + request: LocalIntegrationEndpointTransportRequest, + transport: LocalIntegrationEndpointTransport, + signal: AbortSignal, +): Promise { + let response: Response; + try { + response = await transport(request); + } catch { + requestFailed(); + } + const status = responseStatusValue(response); + if (status < 200 || status >= 300) { + try { + void responseBodyValue(response)?.cancel().catch(() => undefined); + } catch { + // Response cleanup is best effort and must not expose provider errors. + } + requestFailed(); + } + return await readResponseJson(response, signal); +} + function transformResponse(value: unknown, transform: string | undefined): unknown { if (transform === undefined || transform === "") return value; let current = value; @@ -525,23 +559,59 @@ export async function executeLocalIntegrationEndpoint( options.allowedOrigin, signalLease.signal, ); - let response: Response; + const value = await executeTransportRequest( + request, + options.transport ?? guardedTransport, + signalLease.signal, + ); + return transformResponse(value, options.endpoint.response?.transform); + } finally { + signalLease.release(); + } +} + +/** Execute one fixed-origin JSON request, including OAuth token requests. */ +export async function executeLocalIntegrationJsonRequest( + options: ExecuteLocalIntegrationJsonRequestOptions, +): Promise { + const signalLease = createRequestSignal( + options.signal, + options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, + ); + try { + let url: URL; try { - response = await (options.transport ?? guardedTransport)(request); + url = new URLConstructor(options.url); } catch { - requestFailed(); + requestInvalid("Local integration request URL is invalid"); } - const status = responseStatusValue(response); - if (status < 200 || status >= 300) { - try { - void responseBodyValue(response)?.cancel().catch(() => undefined); - } catch { - // Response cleanup is best effort and must not expose provider errors. + if (urlValue(urlOrigin, url) !== options.allowedOrigin) { + requestInvalid("Local integration request origin does not match its admitted origin"); + } + const headers = new HeadersConstructor(); + for (const name of objectKeys(options.headers)) { + const value = ownValue(options.headers, name); + if (!value.present || typeof value.value !== "string") { + requestInvalid("Local integration authorization headers are invalid"); } - requestFailed(); + setHeader(headers, name, value.value); } - const value = await readResponseJson(response, signalLease.signal); - return transformResponse(value, options.endpoint.response?.transform); + const request = freeze({ + url, + allowedOrigin: options.allowedOrigin, + init: freeze({ + method: options.method, + headers, + body: options.body, + redirect: "error" as const, + signal: signalLease.signal, + }), + }); + return await executeTransportRequest( + request, + options.transport ?? guardedTransport, + signalLease.signal, + ); } finally { signalLease.release(); } diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 7993fb84fb..4f8d99680e 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -4,13 +4,26 @@ import { _setEnvironmentConfigForTesting, } from "#veryfront/config/environment-config.ts"; import { VeryfrontError } from "#veryfront/errors"; -import { assert, assertEquals, assertRejects } from "#veryfront/testing/assert.ts"; +import { + assert, + assertEquals, + assertInstanceOf, + assertRejects, +} from "#veryfront/testing/assert.ts"; import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; +import { loadRemoteToolsFromSource } from "#veryfront/tool"; +import { executeConfiguredTool } from "#veryfront/agent/runtime/tool-helpers.ts"; import { createLocalIntegrationToolSource } from "./index.ts"; +import type { LocalIntegrationEndpointTransport } from "./local-endpoint-executor.ts"; +import { _createLocalIntegrationToolSourceForTesting } from "./local-tool-source.ts"; const TEST_CREDENTIAL = "LOCAL_INTEGRATION_SECRET_MUST_NOT_LEAK"; const testCredentialProvider = () => TEST_CREDENTIAL; +function headerValue(request: RequestInit, name: string): string | null { + return new Headers(request.headers).get(name); +} + async function assertConfigurationError( createPromise: () => Promise, expectedDetail: string, @@ -100,6 +113,7 @@ describe("createLocalIntegrationToolSource", () => { { tool: "aws__list-s3-buckets", detail: "endpoint" }, { tool: "github__list_issues", detail: "GraphQL" }, { tool: "gmail__list_emails", detail: "enrichment" }, + { tool: "algolia__list_indices", detail: "fixed HTTPS URL" }, { tool: "alphavantage__quote", detail: "query" }, { tool: "slack__list_channels", detail: "authorization-code" }, ] as const; @@ -152,4 +166,236 @@ describe("createLocalIntegrationToolSource", () => { "not granted", ); }); + + it("executes admitted API-key and Basic tools with project-owned credentials", async () => { + const directRequests: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + directRequests.push(request.url.href); + if (request.url.hostname === "api.vercel.com") { + assertEquals(headerValue(request.init, "authorization"), `Bearer ${TEST_CREDENTIAL}`); + return Promise.resolve(Response.json({ projects: [{ id: "project-1" }] })); + } + assertEquals(request.url.hostname, "panel.sendcloud.sc"); + assertEquals( + headerValue(request.init, "authorization"), + `Basic ${btoa(`public-key:${TEST_CREDENTIAL}`)}`, + ); + return Promise.resolve(Response.json({ data: [{ id: "shipment-1" }] })); + }; + + const vercel = _createLocalIntegrationToolSourceForTesting( + { + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }, + transport, + ); + const sendcloud = _createLocalIntegrationToolSourceForTesting( + { + tools: ["sendcloud__list_shipments"], + credentialProvider: (name) => + name === "SENDCLOUD_PUBLIC_KEY" ? "public-key" : TEST_CREDENTIAL, + }, + transport, + ); + + assertEquals(await vercel.executeTool("vercel__list_projects", {}), { + projects: [{ id: "project-1" }], + }); + assertEquals(await sendcloud.executeTool("sendcloud__list_shipments", {}), [ + { id: "shipment-1" }, + ]); + assertEquals(directRequests, [ + "https://api.vercel.com/v10/projects?limit=20", + "https://panel.sendcloud.sc/api/v3/shipments?page_size=40", + ]); + }); + + it("mints client credentials before executing a fixed-origin provider tool", async () => { + const requests: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + requests.push(request.url.href); + if (request.url.pathname === "/v1/oauth2/token") { + assertEquals(request.init.method, "POST"); + assertEquals( + headerValue(request.init, "authorization"), + `Basic ${btoa(`paypal-client:${TEST_CREDENTIAL}`)}`, + ); + assertEquals(request.init.body, "grant_type=client_credentials"); + return Promise.resolve(Response.json({ + access_token: "paypal-access-token", + token_type: "Bearer", + })); + } + assertEquals(headerValue(request.init, "authorization"), "Bearer paypal-access-token"); + return Promise.resolve(Response.json({ balances: [{ currency_code: "USD" }] })); + }; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["paypal__list_balances"], + credentialProvider: (name) => + name === "PAYPAL_CLIENT_ID" ? "paypal-client" : TEST_CREDENTIAL, + }, + transport, + ); + + assertEquals(await source.executeTool("paypal__list_balances", {}), { + balances: [{ currency_code: "USD" }], + }); + assertEquals(requests, [ + "https://api-m.paypal.com/v1/oauth2/token", + "https://api-m.paypal.com/v1/reporting/balances", + ]); + }); + + it("uses only a validated Salesforce instance origin from service-account tokens", async () => { + const requests: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + requests.push(request.url.href); + if (request.url.pathname === "/services/oauth2/token") { + assertEquals(request.url.origin, "https://acme.my.salesforce.com"); + assertEquals( + request.init.body, + [ + "grant_type=client_credentials", + "client_id=salesforce-client", + `client_secret=${TEST_CREDENTIAL}`, + ].join("&"), + ); + return Promise.resolve(Response.json({ + access_token: "salesforce-access-token", + instance_url: "https://customer.my.salesforce.com", + token_type: "Bearer", + })); + } + assertEquals(request.url.origin, "https://customer.my.salesforce.com"); + assertEquals( + headerValue(request.init, "authorization"), + "Bearer salesforce-access-token", + ); + return Promise.resolve(Response.json({ records: [{ Id: "contact-1" }] })); + }; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["salesforce__find_customer"], + credentialProvider: (name) => { + if (name === "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID") return "salesforce-client"; + if (name === "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL") { + return "https://acme.my.salesforce.com"; + } + return TEST_CREDENTIAL; + }, + }, + transport, + ); + + assertEquals(await source.executeTool("salesforce__find_customer", {}), [ + { Id: "contact-1" }, + ]); + assertEquals(requests.length, 2); + assert( + requests[1]?.startsWith( + "https://customer.my.salesforce.com/services/data/v61.0/query?q=SELECT+Id", + ), + ); + }); + + it("rejects malformed Salesforce token payloads before endpoint execution", async () => { + const invalidPayloads = [ + {}, + { access_token: TEST_CREDENTIAL }, + { + access_token: TEST_CREDENTIAL, + instance_url: "https://example.com", + token_type: "Bearer", + }, + { + access_token: TEST_CREDENTIAL, + instance_url: "http://acme.my.salesforce.com", + token_type: "Bearer", + }, + { + access_token: TEST_CREDENTIAL, + instance_url: "https://127.0.0.1", + token_type: "Bearer", + }, + { + access_token: TEST_CREDENTIAL, + instance_url: "https://acme.my.salesforce.com/private", + token_type: "Bearer", + }, + { + access_token: TEST_CREDENTIAL, + instance_url: "https://user@acme.my.salesforce.com", + token_type: "Bearer", + }, + { + access_token: TEST_CREDENTIAL, + instance_url: "https://acme.my.salesforce.com:8443", + token_type: "Bearer", + }, + ]; + + for (const payload of invalidPayloads) { + let calls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["salesforce__find_customer"], + credentialProvider: (name) => + name === "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL" + ? "https://acme.my.salesforce.com" + : TEST_CREDENTIAL, + }, + () => { + calls += 1; + return Promise.resolve(Response.json(payload)); + }, + ); + + const error = await assertRejects( + () => source.executeTool("salesforce__find_customer", {}), + VeryfrontError, + ); + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-response-invalid"); + assertEquals(error.message.includes(TEST_CREDENTIAL), false); + assertEquals(error.cause, undefined); + assertEquals(calls, 1); + } + }); + + it("keeps source integration policy narrowing over materialized local tools", async () => { + let transportCalls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }, + () => { + transportCalls += 1; + return Promise.resolve(Response.json({ projects: [] })); + }, + ); + const tools = await loadRemoteToolsFromSource(source); + + await assertRejects( + () => + executeConfiguredTool( + "vercel__list_projects", + {}, + tools, + undefined, + ["vercel__list_projects"], + undefined, + { + schemaVersion: 1, + mode: "allowlist", + integrations: { vercel: { allowedToolIds: ["get_project"] } }, + }, + ), + Error, + 'Tool "vercel__list_projects" is not allowed by the source integration policy', + ); + assertEquals(transportCalls, 0); + }); }); diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 371d3d763b..b524b20026 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -10,8 +10,13 @@ import { connectors } from "./_data.ts"; import { createLocalCredentialAuthPlan, type LocalCredentialAuthPlan, + mintLocalCredentialAuth, resolveLocalCredentialAuth, } from "./local-credential-auth.ts"; +import { + executeLocalIntegrationEndpoint, + type LocalIntegrationEndpointTransport, +} from "./local-endpoint-executor.ts"; import { localIntegrationConfigurationError } from "./local-integration-errors.ts"; import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; import { parseIntegrationToolIdentity } from "./source-policy.ts"; @@ -36,6 +41,7 @@ interface AdmittedLocalIntegrationTool { readonly authPlan: LocalCredentialAuthPlan; readonly connector: IntegrationConfig; readonly endpoint: IntegrationEndpoint; + readonly endpointOrigin?: string; readonly tool: IntegrationToolMeta & { id: string }; readonly definition: ToolDefinition; } @@ -133,7 +139,7 @@ function catalogTool( return undefined; } -function assertHttpsCatalogUrl(value: string, label: string): void { +function assertHttpsCatalogUrl(value: string, label: string): string { let parsed: URL; try { parsed = new URL(value); @@ -142,10 +148,11 @@ function assertHttpsCatalogUrl(value: string, label: string): void { } if ( parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || - value.includes("{{") + value.includes("{{") || parsed.hostname.includes("{") || parsed.hostname.includes("}") ) { configurationError(`${label} must be a fixed HTTPS URL without credentials`); } + return parsed.origin; } function assertSupportedAuth( @@ -192,7 +199,7 @@ function assertSupportedEndpoint( connector: IntegrationConfig, endpoint: IntegrationEndpoint, toolId: string, -): void { +): string | undefined { if (endpoint.type === "graphql") { configurationError(`Local integration tool "${toolId}" uses unsupported GraphQL execution`); } @@ -212,8 +219,12 @@ function assertSupportedEndpoint( if (!endpoint.url.startsWith("{{oauth.raw.instance_url}}/")) { configurationError(`Local Salesforce tool "${toolId}" has an unsupported endpoint template`); } + return undefined; } else { - assertHttpsCatalogUrl(endpoint.url, `Local integration tool "${toolId}" endpoint`); + return assertHttpsCatalogUrl( + endpoint.url, + `Local integration tool "${toolId}" endpoint`, + ); } } @@ -291,12 +302,17 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { configurationError(`Local integration tool "${canonicalToolId}" has no executable endpoint`); } - assertSupportedEndpoint(connector, tool.endpoint, canonicalToolId); + const endpointOrigin = assertSupportedEndpoint( + connector, + tool.endpoint, + canonicalToolId, + ); assertSupportedAuth(connector, tool.endpoint); return Object.freeze({ authPlan: createLocalCredentialAuthPlan(connector), connector, endpoint: tool.endpoint, + endpointOrigin, tool, definition: toolDefinition(tool, tool.endpoint), }); @@ -311,9 +327,9 @@ function assertLocalRuntime(): void { } } -/** Create an explicitly granted, catalog-backed local integration tool source. */ -export function createLocalIntegrationToolSource( +function createLocalIntegrationToolSourceInternal( options: LocalIntegrationToolSourceOptions, + transport?: LocalIntegrationEndpointTransport, ): RemoteToolSource { const snapshot = snapshotOptions(options); const admitted = new Map(); @@ -341,14 +357,60 @@ export function createLocalIntegrationToolSource( }, async executeTool( toolName: string, - _args: Record, - _context?: ToolExecutionContext, + args: Record, + context?: ToolExecutionContext, ): Promise { assertLocalRuntime(); - if (!admitted.has(toolName)) { + const tool = admitted.get(toolName); + if (!tool) { configurationError(`Local integration tool "${toolName}" is not granted by this source`); } - configurationError(`Local integration tool "${toolName}" execution is not implemented`); + const auth = await mintLocalCredentialAuth( + await resolveLocalCredentialAuth(tool.authPlan, credentialProvider), + context?.abortSignal, + transport, + ); + let endpoint = tool.endpoint; + let allowedOrigin = tool.endpointOrigin; + if (tool.connector.name === "salesforce") { + if (!auth.instanceOrigin) { + configurationError("Local Salesforce execution requires a validated instance origin"); + } + endpoint = Object.freeze({ + ...endpoint, + url: endpoint.url.replace( + "{{oauth.raw.instance_url}}", + auth.instanceOrigin, + ), + }); + allowedOrigin = auth.instanceOrigin; + } + if (!allowedOrigin) { + configurationError(`Local integration tool "${toolName}" has no admitted origin`); + } + return await executeLocalIntegrationEndpoint({ + endpoint, + args, + authHeaders: auth.headers, + allowedOrigin, + signal: context?.abortSignal, + transport, + }); }, }); } + +/** Create an explicitly granted, catalog-backed local integration tool source. */ +export function createLocalIntegrationToolSource( + options: LocalIntegrationToolSourceOptions, +): RemoteToolSource { + return createLocalIntegrationToolSourceInternal(options); +} + +/** @internal Test-only transport seam; not exported from the public integrations module. */ +export function _createLocalIntegrationToolSourceForTesting( + options: LocalIntegrationToolSourceOptions, + transport: LocalIntegrationEndpointTransport, +): RemoteToolSource { + return createLocalIntegrationToolSourceInternal(options, transport); +} From 874e29d258f54cfe9eebe8b4d00a9c0394b34857 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:25:28 +0200 Subject: [PATCH 07/25] Make local integration credentials discoverable without an account The public guides now separate managed OAuth from the catalog-backed local credential path and lock the exact-grant and secret-isolation contracts with executable documentation tests. Constraint: Local execution must not require or contact the Veryfront control plane. Rejected: Document integrations.allow as credential selection | it is narrowing-only capability policy. Confidence: high Scope-risk: narrow Directive: Keep managed per-user OAuth distinct from local service-account execution. Tested: docs validation, guide contracts, executable examples, public copy checks, pinned Deno 2.7.7 API reference check Not-tested: live provider credentials --- docs/api-reference/veryfront/integrations.md | 51 +++++++++++--------- docs/guides/integrations.md | 45 ++++++++++++++++- docs/guides/integrations/salesforce.md | 38 +++++++++++++-- docs/guides/self-hosting.md | 24 ++++++--- tests/docs/guide-code-examples.test.ts | 29 +++++++++++ tests/docs/guide-content.test.ts | 20 ++++++++ tests/docs/guide-contracts.test.ts | 9 ++++ 7 files changed, 181 insertions(+), 35 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index 1dd69583ff..57b82f75c2 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -8,12 +8,12 @@ order: 14 ```ts import { + createLocalIntegrationToolSource, executeRemoteIntegrationTool, getConnector, getConnectorNames, getIcon, getRemoteIntegrationToolDefinitions, - getRemoteIntegrationToolDiscovery, } from "veryfront/integrations"; ``` @@ -52,29 +52,32 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); ### Functions -| Name | Description | Source | -| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | -| `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | -| `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | -| `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | -| `getIcon` | Return icon. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L67) | -| `getRemoteIntegrationToolDefinitions` | Fetch integration tool definitions for the current request context. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L807) | -| `getRemoteIntegrationToolDiscovery` | Discover integration tools for the current request context. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L758) | -| `isRemoteIntegrationTool` | Check if a tool name looks like a remote integration tool. Integration tools use "integration__tool_id" format (double underscore separator). | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L818) | -| `listConnectors` | List connectors. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L57) | +| Name | Description | Source | +| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L404) | +| `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | +| `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | +| `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | +| `getIcon` | Return icon. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L67) | +| `getRemoteIntegrationToolDefinitions` | Fetch integration tool definitions for the current request context. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L807) | +| `getRemoteIntegrationToolDiscovery` | Discover integration tools for the current request context. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L758) | +| `isRemoteIntegrationTool` | Check if a tool name looks like a remote integration tool. Integration tools use "integration__tool_id" format (double underscore separator). | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L818) | +| `listConnectors` | List connectors. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L57) | ### Types -| Name | Description | Source | -| -------------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | -| `EnvVarConfig` | Configuration used by env var. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L485) | -| `IntegrationConfig` | Configuration used by integration. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L499) | -| `IntegrationConnector` | Public API contract for integration connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L77) | -| `IntegrationEndpointHistoricalSummary` | Provider-declared summary contract for old tool outputs kept actionable across turns. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L493) | -| `IntegrationName` | Public API contract for integration name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L483) | -| `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | -| `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | -| `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | -| `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | -| `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | +| Name | Description | Source | +| -------------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | +| `EnvVarConfig` | Configuration used by env var. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L485) | +| `IntegrationConfig` | Configuration used by integration. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L499) | +| `IntegrationConnector` | Public API contract for integration connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L77) | +| `IntegrationEndpointHistoricalSummary` | Provider-declared summary contract for old tool outputs kept actionable across turns. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L493) | +| `IntegrationName` | Public API contract for integration name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L483) | +| `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | +| `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | +| `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L26) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L31) | +| `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | +| `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | +| `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | diff --git a/docs/guides/integrations.md b/docs/guides/integrations.md index 18dd988cac..5b1604e377 100644 --- a/docs/guides/integrations.md +++ b/docs/guides/integrations.md @@ -13,11 +13,52 @@ inventory records credential readiness independently of all three. - A Veryfront project with a configured agent (see [Agents](./agents.md)). - The integration tool names the agent needs. -- A project token or hosted runtime that can reach the Veryfront integration - tool endpoints. +- For managed execution, a project token or hosted runtime that can reach the + Veryfront integration tool endpoints. +- For local execution, provider credentials in the project environment. - Project environment credentials only for static-credential connectors or an explicitly selected custom OAuth app override (see [OAuth](./oauth.md)). +## Run account-free local integration tools + +Use the catalog-backed local source when a local or self-hosted project should +call supported REST integrations without a Veryfront account or project token: + +```ts +import { agent } from "veryfront/agent"; +import { createLocalIntegrationToolSource } from "veryfront/integrations"; +import { loadRemoteToolsFromSource } from "veryfront/tool"; + +const source = createLocalIntegrationToolSource({ + tools: ["salesforce__find_customer"], +}); +const integrationTools = await loadRemoteToolsFromSource(source); + +export default agent({ + system: "Use Salesforce when the user asks about a customer.", + tools: integrationTools, +}); +``` + +The exact canonical IDs passed to `tools` are the source's capability grant. +Source configuration is monotonic: integrations.allow only narrows that grant +when the source runs inside a Veryfront project runtime. It never enables +another tool or selects a credential. The runtime resolves each credential +immediately before the request and never sends local credentials to Veryfront, +the model, tool arguments, logs, or request URLs. + +By default, the source reads the credential environment variables declared by +the connector catalog from the active project environment. An application can +instead pass a `credentialProvider` that resolves those names from its own +secret manager. The provider receives credential names only. + +This first local execution path supports fixed HTTPS REST endpoints with +header API keys, Basic authentication, OAuth 2.0 client credentials, and the +Salesforce service-account specialization. It rejects authorization-code OAuth, +query-string credentials, GraphQL, response enrichment, multipart bodies, raw +bodies, dynamic endpoint origins, and tools outside the exact grant. Use managed +execution for per-user OAuth and other unsupported connector features. + ## Declare agent tool access List integration tools alongside the agent's other tools: diff --git a/docs/guides/integrations/salesforce.md b/docs/guides/integrations/salesforce.md index 29e9baf552..7230b467a5 100644 --- a/docs/guides/integrations/salesforce.md +++ b/docs/guides/integrations/salesforce.md @@ -12,11 +12,13 @@ account for scheduled or project-owned automation. - A Salesforce administrator for the target org. - A Veryfront project with Salesforce tools declared in an agent. -- The hosted Veryfront API, which supplies the Salesforce provider adapter. The - generic Veryfront runtime cannot scaffold or execute Salesforce OAuth routes. - An embedding host that supplies its own Salesforce adapter must declare +- The hosted Veryfront API for per-user OAuth, which supplies the Salesforce + provider adapter. The generic runtime does not scaffold Salesforce OAuth + routes. An embedding host that supplies its own Salesforce adapter must declare `VERYFRONT_HOST_ADAPTER_INTEGRATIONS=salesforce` to expose the connector catalog. This does not enable generic Salesforce scaffolding. +- For account-free local service-account execution, a Veryfront Code project + and Salesforce service-account credentials in its environment. ## Connect a Salesforce user @@ -79,6 +81,36 @@ Veryfront fails closed and does not fall back to a human OAuth connection for non-interactive runs. Rotate the consumer secret in Salesforce and update the project environment variable through the approved secret-management workflow. +### Run Salesforce locally + +Create an exact-grant local source, load its tools, and pass them to an agent: + +```ts +import { agent } from "veryfront/agent"; +import { createLocalIntegrationToolSource } from "veryfront/integrations"; +import { loadRemoteToolsFromSource } from "veryfront/tool"; + +const source = createLocalIntegrationToolSource({ + tools: ["salesforce__find_customer"], +}); +const integrationTools = await loadRemoteToolsFromSource(source); + +export default agent({ + system: "Use Salesforce when the user asks about a customer.", + tools: integrationTools, +}); +``` + +This path needs no Veryfront account, project token, or hosted integration API. +It reads the three service-account variables from the active project environment, +exchanges them at the configured Salesforce My Domain, and sends the resulting +bearer token only to that org's returned My Domain instance. Raw credentials and +tokens never enter the tool definition, model prompt, arguments, logs, or URLs. + +Local Salesforce execution supports the catalog's fixed REST tools and the +client-credentials service account only. Keep using managed execution for a +Salesforce user's authorization-code OAuth connection. + ## Verify it worked 1. Start a new agent run that uses a read-only Salesforce tool, such as account or case lookup. diff --git a/docs/guides/self-hosting.md b/docs/guides/self-hosting.md index cc6a156a46..b51e6e687f 100644 --- a/docs/guides/self-hosting.md +++ b/docs/guides/self-hosting.md @@ -25,15 +25,27 @@ Choose substitutes for managed capabilities before you deploy. | Local agent delegation with `delegates` | Supported | Delegates run in the application process. | | Workflows | Supported | Use the in-memory backend or configure Redis for shared durable state. | | Source-controlled project knowledge | Supported | Use the local project directory and the project knowledge tools. | -| Remote integration tools | Requires a backing API or service layer | Managed Salesforce and other remote tools have no standalone credential path. | +| Remote integration tools | Supported subset | Use a local source or managed backing API. | | Sandbox sessions | Requires a backing API or service layer | Configure authenticated sandbox session APIs. | | Veryfront Cloud routing, storage, and runs | Requires Veryfront Cloud | These capabilities depend on project and control-plane context. | -Remote integration definitions and execution are fetched from the configured -API layer. A provider model key does not make managed integration tools such as -`salesforce__*` available in a standalone project. Build a local tool against -the service API, or provide the backing service layer, until a standalone -credential path exists. +For supported fixed REST tools, create a local source with the exact canonical +tool IDs the application grants: + +```ts +import { createLocalIntegrationToolSource } from "veryfront/integrations"; +import { loadRemoteToolsFromSource } from "veryfront/tool"; + +const source = createLocalIntegrationToolSource({ + tools: ["salesforce__find_customer"], +}); +const integrationTools = await loadRemoteToolsFromSource(source); +``` + +Pass `integrationTools` to an agent's `tools` option. The source resolves +credentials from the project environment by default and never sends them to +Veryfront. Managed per-user OAuth and connector features outside the supported +local subset still require the configured API layer. ## Build the project diff --git a/tests/docs/guide-code-examples.test.ts b/tests/docs/guide-code-examples.test.ts index 5afa1017d3..070b8d7ba3 100644 --- a/tests/docs/guide-code-examples.test.ts +++ b/tests/docs/guide-code-examples.test.ts @@ -56,11 +56,13 @@ import { schedule } from "../../src/schedule/index.ts"; import { webhook } from "../../src/webhook/index.ts"; import { isTaskDefinition } from "../../src/task/types.ts"; import { + createLocalIntegrationToolSource, getConnector, getIcon, getRemoteIntegrationToolDefinitions, listConnectors, } from "../../src/integrations/index.ts"; +import { loadRemoteToolsFromSource } from "../../src/tool/index.ts"; import { parseDeployArgs } from "../../cli/commands/deploy/command.ts"; import { buildKnowledgeIngestRunResult } from "../../cli/commands/knowledge/result.ts"; import { parsePullArgs } from "../../cli/commands/pull/command.ts"; @@ -107,6 +109,7 @@ const THIS_GUIDE_EXAMPLE_SUITE = [ "create-api.md", "deploy-project.md", "integrations.md", + "integrations/salesforce.md", "move-studio-changes-to-git.md", "pages-and-routing.md", "project-knowledge.md", @@ -927,6 +930,32 @@ describe("Guide: integrations.md", () => { assertExists(githubIcon); assertEquals(typeof getRemoteIntegrationToolDefinitions, "function"); }); + + it("loads an exact-grant local integration source with named credentials", async () => { + const credentials = new Map([ + ["SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID", "client-id"], + ["SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET", "client-secret"], + [ + "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL", + "https://acme.my.salesforce.com", + ], + ]); + const source = createLocalIntegrationToolSource({ + tools: ["salesforce__find_customer"], + credentialProvider: (name) => credentials.get(name), + }); + + const integrationTools = await loadRemoteToolsFromSource(source); + + assertEquals(Object.keys(integrationTools), ["salesforce__find_customer"]); + }); +}); + +describe("Guide: integrations/salesforce.md", () => { + it("uses the public local integration source and remote tool loader", () => { + assertEquals(typeof createLocalIntegrationToolSource, "function"); + assertEquals(typeof loadRemoteToolsFromSource, "function"); + }); }); describe("Guide: pages-and-routing.md", () => { diff --git a/tests/docs/guide-content.test.ts b/tests/docs/guide-content.test.ts index 704c6d2da8..ea5938db60 100644 --- a/tests/docs/guide-content.test.ts +++ b/tests/docs/guide-content.test.ts @@ -285,6 +285,26 @@ describe("guide content contracts", () => { assertStringIncludes(guide, "`scope`, `perUser`, and\n`tools` fields are rejected"); }); + it("documents account-free local integration credentials without weakening grants", async () => { + const integrations = await Deno.readTextFile("docs/guides/integrations.md"); + const salesforce = await Deno.readTextFile( + "docs/guides/integrations/salesforce.md", + ); + const selfHosting = await Deno.readTextFile("docs/guides/self-hosting.md"); + const docs = [integrations, salesforce, selfHosting].join("\n"); + + assertStringIncludes(docs, "createLocalIntegrationToolSource"); + assertStringIncludes(docs, "loadRemoteToolsFromSource"); + assertStringIncludes(docs, "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID"); + assertStringIncludes(docs, "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET"); + assertStringIncludes(docs, "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL"); + assertStringIncludes(integrations, "integrations.allow only narrows"); + assertStringIncludes(integrations, "never sends local credentials to Veryfront"); + assertStringIncludes(integrations, "authorization-code OAuth"); + assertStringIncludes(integrations, "query-string credentials"); + assertEquals(selfHosting.includes("have no standalone credential path"), false); + }); + it("documents fail-closed extension activation modes", async () => { const guide = await Deno.readTextFile( "docs/guides/extension-authoring.md", diff --git a/tests/docs/guide-contracts.test.ts b/tests/docs/guide-contracts.test.ts index 6cd904f3cf..a9d7196c24 100644 --- a/tests/docs/guide-contracts.test.ts +++ b/tests/docs/guide-contracts.test.ts @@ -330,6 +330,8 @@ const GUIDE_CONTRACTS: Record = { "Dockerfile", "Check capability support", "Remote integration tools", + "createLocalIntegrationToolSource", + "loadRemoteToolsFromSource", "Deploy to Kubernetes", "--from-env-file=.env", "startupProbe:", @@ -623,6 +625,10 @@ const GUIDE_CONTRACTS: Record = { "Connection inventory", "veryfront.config.ts", "Managed OAuth", + "createLocalIntegrationToolSource", + "loadRemoteToolsFromSource", + "integrations.allow only narrows", + "never sends local credentials to Veryfront", "Available integrations", ], }, @@ -654,6 +660,9 @@ const GUIDE_CONTRACTS: Record = { "Connect a Salesforce user", "VERYFRONT_HOST_ADAPTER_INTEGRATIONS=salesforce", "SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID", + "SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET", + "SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL", + "createLocalIntegrationToolSource", "Admin approved users are pre-authorized", "Verify it worked", ], From 52ae29eef79b7ff09396d648339e2d4274a6911e Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 05:43:21 +0200 Subject: [PATCH 08/25] Keep local credential execution stable in a shared host realm Capture the collection, URL, abort, response, and string primitives used by local integration admission and execution. Adversarial tests now prove project code cannot replace those ambient primitives to widen grants, erase credentials, or skip bounded response cleanup. Constraint: Project modules share the host realm before local sources list or execute tools. Rejected: Trust ambient collection prototypes | project code can replace them after framework initialization. Confidence: high Scope-risk: moderate Directive: Keep local integration admission and credential execution on captured primitives and own-property array writes. Tested: 15 integration suites (215 steps), focused hardening suites (28 steps), production check, fmt, lint, anti-slop, test-typecheck baseline, docs validation, public docs, error docs, pinned API-reference generation/check. Not-tested: Live provider credentials or production provider endpoints. --- docs/api-reference/veryfront/integrations.md | 6 +- .../local-credential-auth.test.ts | 124 ++++++++++++++- src/integrations/local-credential-auth.ts | 84 +++++++--- .../local-endpoint-executor.test.ts | 146 ++++++++++++++++++ src/integrations/local-endpoint-executor.ts | 39 ++++- src/integrations/local-tool-source.test.ts | 109 +++++++++++++ src/integrations/local-tool-source.ts | 143 ++++++++++++----- src/integrations/source-policy.ts | 47 +++++- 8 files changed, 623 insertions(+), 75 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index 57b82f75c2..e328810d30 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -54,7 +54,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L404) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L473) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | | `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | @@ -76,8 +76,8 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | | `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | | `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L26) | -| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L31) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L51) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L56) | | `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | | `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | | `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index 8183b9eac1..0c5c4b15a8 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -1,6 +1,11 @@ import "#veryfront/schemas/_test-setup.ts"; import { VeryfrontError } from "#veryfront/errors"; -import { assert, assertEquals, assertRejects } from "#veryfront/testing/assert.ts"; +import { + assert, + assertEquals, + assertInstanceOf, + assertRejects, +} from "#veryfront/testing/assert.ts"; import { describe, it } from "#veryfront/testing/bdd.ts"; import { connectors } from "./_data.ts"; import { @@ -10,6 +15,48 @@ import { import type { LocalIntegrationCredentialProvider } from "./local-tool-source.ts"; const SECRET = "LOCAL_PROVIDER_SECRET_MUST_NOT_LEAK"; +const defineProperty = Object.defineProperty; +const deleteProperty = Reflect.deleteProperty; +const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +function appendRestorer(restorers: Array<() => void>, restorer: () => void): void { + defineProperty(restorers, restorers.length, { + configurable: true, + enumerable: true, + value: restorer, + writable: true, + }); +} + +function replaceProperty( + target: object, + key: PropertyKey, + value: unknown, +): () => void { + const descriptor = getOwnPropertyDescriptor(target, key); + defineProperty(target, key, { + configurable: true, + value, + writable: true, + }); + return () => { + if (descriptor) defineProperty(target, key, descriptor); + else deleteProperty(target, key); + }; +} + +function replaceDescriptor( + target: object, + key: PropertyKey, + descriptor: PropertyDescriptor, +): () => void { + const previous = getOwnPropertyDescriptor(target, key); + defineProperty(target, key, descriptor); + return () => { + if (previous) defineProperty(target, key, previous); + else deleteProperty(target, key); + }; +} function connector(name: string) { const value = connectors.find((candidate) => candidate.name === name); @@ -86,7 +133,7 @@ describe("local integration credential auth", () => { }), ); - assertEquals(resolved.kind, "token-request"); + assert(resolved.kind === "token-request"); assertEquals(resolved.mode, "client-credentials"); assertEquals(resolved.url, "https://api-m.paypal.com/v1/oauth2/token"); assertEquals(resolved.headers, { @@ -114,7 +161,7 @@ describe("local integration credential auth", () => { }), ); - assertEquals(resolved.kind, "token-request"); + assert(resolved.kind === "token-request"); assertEquals(resolved.mode, "salesforce-service-account"); assertEquals(resolved.url, "https://acme.my.salesforce.com/services/oauth2/token"); assertEquals(resolved.headers, { @@ -127,6 +174,72 @@ describe("local integration credential auth", () => { ); }); + it("keeps credential resolution independent from ambient collection primordials", async () => { + const paypalConnector = connector("paypal"); + const salesforceConnector = connector("salesforce"); + const restorers: Array<() => void> = []; + let poisonCalls = 0; + const poison = (): never => { + poisonCalls += 1; + throw new Error("ambient credential primordial used"); + }; + let paypal: Awaited> | undefined; + let salesforce: Awaited> | undefined; + + try { + appendRestorer(restorers, replaceProperty(Array, "isArray", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "indexOf", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "join", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "push", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "splice", poison)); + appendRestorer(restorers, replaceProperty(Object, "create", poison)); + appendRestorer(restorers, replaceProperty(Object, "entries", poison)); + appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); + appendRestorer(restorers, replaceProperty(Object, "values", poison)); + appendRestorer(restorers, replaceProperty(String, "fromCharCode", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "endsWith", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "toLowerCase", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "trim", poison)); + appendRestorer( + restorers, + replaceDescriptor(Array.prototype, "0", { + configurable: true, + set: poison, + }), + ); + + paypal = await resolveLocalCredentialAuth( + createLocalCredentialAuthPlan(paypalConnector), + providerFrom({ + PAYPAL_CLIENT_ID: "paypal-client", + PAYPAL_CLIENT_SECRET: SECRET, + }), + ); + salesforce = await resolveLocalCredentialAuth( + createLocalCredentialAuthPlan(salesforceConnector), + providerFrom({ + SALESFORCE_SERVICE_ACCOUNT_CLIENT_ID: "salesforce-client", + SALESFORCE_SERVICE_ACCOUNT_CLIENT_SECRET: SECRET, + SALESFORCE_SERVICE_ACCOUNT_LOGIN_URL: "https://acme.my.salesforce.com", + }), + ); + } finally { + for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); + } + + assertEquals(poisonCalls, 0); + assert(paypal); + assert(paypal.kind === "token-request"); + assert(Object.isFrozen(paypal)); + assertEquals(paypal.body, "grant_type=client_credentials"); + assert(salesforce); + assert(salesforce.kind === "token-request"); + assert(Object.isFrozen(salesforce)); + assertEquals(salesforce.url, "https://acme.my.salesforce.com/services/oauth2/token"); + }); + it("reports only missing variable names and calls a provider with names only", async () => { const calls: string[] = []; const plan = createLocalCredentialAuthPlan(connector("sendcloud")); @@ -140,6 +253,7 @@ describe("local integration credential auth", () => { ); assertEquals(calls, ["SENDCLOUD_PUBLIC_KEY", "SENDCLOUD_SECRET_KEY"]); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-credentials-missing"); assert(error.message.includes("SENDCLOUD_SECRET_KEY")); assertEquals(error.message.includes("public-key"), false); @@ -153,6 +267,7 @@ describe("local integration credential auth", () => { () => resolveLocalCredentialAuth(plan, () => value), VeryfrontError, ); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-credentials-missing"); if (value.length > 16_384) { assertEquals(error.message.includes(value), false); @@ -166,6 +281,7 @@ describe("local integration credential auth", () => { }), VeryfrontError, ); + assertInstanceOf(providerError, VeryfrontError); assertEquals(providerError.slug, "local-integration-credential-unavailable"); assertEquals(providerError.message.includes(SECRET), false); assertEquals(providerError.cause, undefined); @@ -192,6 +308,7 @@ describe("local integration credential auth", () => { ), VeryfrontError, ); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-config-invalid"); assertEquals(error.message.includes(SECRET), false); } @@ -203,6 +320,7 @@ describe("local integration credential auth", () => { async () => createLocalCredentialAuthPlan(connector(name)), VeryfrontError, ); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-config-invalid"); } }); diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index 1d33cc3003..f96e2aef03 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -14,10 +14,18 @@ import { MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH } from "./limits.ts"; const apply = Reflect.apply; const arrayIsArray = Array.isArray; +const arrayJoin = Array.prototype.join; const encodeUriComponent = encodeURIComponent; const freeze = Object.freeze; const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +const objectCreate = Object.create; +const objectDefineProperty = Object.defineProperty; +const objectEntries = Object.entries; +const objectValues = Object.values; +const stringCharCodeAt = String.prototype.charCodeAt; const stringEndsWith = String.prototype.endsWith; +const stringIncludes = String.prototype.includes; +const stringFromCharCode = String.fromCharCode; const stringToLowerCase = String.prototype.toLowerCase; const stringTrim = String.prototype.trim; const textEncoder = new TextEncoder(); @@ -110,6 +118,23 @@ function stringEndsWithValue(value: string, suffix: string): boolean { return apply(stringEndsWith, value, [suffix]); } +function stringIncludesValue(value: string, search: string): boolean { + return apply(stringIncludes, value, [search]); +} + +function append(values: T[], value: T): void { + objectDefineProperty(values, values.length, { + configurable: true, + enumerable: true, + value, + writable: true, + }); +} + +function join(values: readonly string[], separator: string): string { + return apply(arrayJoin, values, [separator]) as string; +} + function urlValue(getter: ((this: URL) => string) | undefined, url: URL): string { if (!getter) localIntegrationConfigurationError("URL parsing is unavailable in this runtime"); return apply(getter, url, []); @@ -139,8 +164,8 @@ function assertFixedHttpsUrl(value: string, label: string): string { function normalizedConnectorPrefix(name: string): string { let prefix = ""; for (let index = 0; index < name.length; index++) { - const code = name.charCodeAt(index); - if (code >= 97 && code <= 122) prefix += String.fromCharCode(code - 32); + const code = apply(stringCharCodeAt, name, [index]) as number; + if (code >= 97 && code <= 122) prefix += stringFromCharCode(code - 32); else if (code >= 65 && code <= 90 || code >= 48 && code <= 57) prefix += name[index]; else prefix += "_"; } @@ -189,7 +214,11 @@ export function createLocalCredentialAuthPlan( ); } const additionalHeaders = freeze({ ...auth.additionalHeaders }); - const required = [auth.keyName, ...Object.values(additionalHeaders)]; + const required = [auth.keyName]; + const additionalNames = objectValues(additionalHeaders); + for (let index = 0; index < additionalNames.length; index++) { + append(required, additionalNames[index]!); + } return freeze({ kind: "api-key", connectorName: connector.name, @@ -218,7 +247,7 @@ export function createLocalCredentialAuthPlan( } if (auth.type === "oauth2" && auth.grantType === "client_credentials") { - if (!auth.tokenUrl || auth.tokenUrl.includes("{{")) { + if (!auth.tokenUrl || stringIncludesValue(auth.tokenUrl, "{{")) { localIntegrationConfigurationError( `Local integration "${connector.name}" requires a fixed token URL`, ); @@ -233,7 +262,7 @@ export function createLocalCredentialAuthPlan( connectorName: connector.name, clientIdName, clientSecretName, - scopes: freeze([...(auth.scopes ?? [])]), + scopes: freeze(copyStrings(auth.scopes ?? [])), tokenAuthMethod: requestBodyAuth ? "request-body" : "basic", tokenUrl: assertFixedHttpsUrl( auth.tokenUrl, @@ -248,6 +277,12 @@ export function createLocalCredentialAuthPlan( ); } +function copyStrings(values: readonly string[]): string[] { + const copied: string[] = []; + for (let index = 0; index < values.length; index++) append(copied, values[index]!); + return copied; +} + function base64(value: string): string { const bytes = apply(textEncoderEncode, textEncoder, [value]) as Uint8Array; const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; @@ -295,12 +330,12 @@ async function readCredentials( plan: LocalCredentialAuthPlan, provider: LocalIntegrationCredentialProvider, ): Promise> { - const values: Record = Object.create(null); + const values: Record = objectCreate(null); const missing: string[] = []; for (let index = 0; index < plan.requiredEnvironmentVariables.length; index++) { const name = plan.requiredEnvironmentVariables[index]!; const value = await readCredential(provider, plan.connectorName, name); - if (value === undefined) missing.push(name); + if (value === undefined) append(missing, name); else values[name] = value; } if ( @@ -308,12 +343,23 @@ async function readCredentials( plan.passwordFallback !== undefined ) { values[plan.passwordName] = plan.passwordFallback; - const missingIndex = missing.indexOf(plan.passwordName); - if (missingIndex >= 0) missing.splice(missingIndex, 1); + for (let index = 0; index < missing.length; index++) { + if (missing[index] !== plan.passwordName) continue; + for (let next = index + 1; next < missing.length; next++) { + objectDefineProperty(missing, next - 1, { + configurable: true, + enumerable: true, + value: missing[next], + writable: true, + }); + } + missing.length -= 1; + break; + } } if (missing.length > 0) { throw LOCAL_INTEGRATION_CREDENTIALS_MISSING.create({ - detail: `Set local integration credential variables: ${missing.join(", ")}`, + detail: `Set local integration credential variables: ${join(missing, ", ")}`, }); } return values; @@ -390,9 +436,11 @@ export async function resolveLocalCredentialAuth( if (plan.kind === "api-key") { const key = values[plan.keyName]!; - const headers: Record = Object.create(null); + const headers: Record = objectCreate(null); headers[plan.headerName] = plan.headerPrefix ? `${plan.headerPrefix} ${key}` : key; - for (const [headerName, environmentName] of Object.entries(plan.additionalHeaders)) { + const additionalEntries = objectEntries(plan.additionalHeaders); + for (let index = 0; index < additionalEntries.length; index++) { + const [headerName, environmentName] = additionalEntries[index]!; headers[headerName] = values[environmentName]!; } return freeze({ kind: "headers", connectorName: plan.connectorName, headers: freeze(headers) }); @@ -411,14 +459,14 @@ export async function resolveLocalCredentialAuth( const clientId = values[plan.clientIdName]!; const clientSecret = values[plan.clientSecretName]!; const body = [formEntry("grant_type", "client_credentials")]; - if (plan.scopes.length > 0) body.push(formEntry("scope", plan.scopes.join(" "))); + if (plan.scopes.length > 0) append(body, formEntry("scope", join(plan.scopes, " "))); const headers: Record = { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded", }; if (plan.tokenAuthMethod === "request-body") { - body.push(formEntry("client_id", clientId)); - body.push(formEntry("client_secret", clientSecret)); + append(body, formEntry("client_id", clientId)); + append(body, formEntry("client_secret", clientSecret)); } else { headers.Authorization = `Basic ${base64(`${clientId}:${clientSecret}`)}`; } @@ -428,7 +476,7 @@ export async function resolveLocalCredentialAuth( mode: "client-credentials", url: plan.tokenUrl, headers: freeze(headers), - body: body.join("&"), + body: join(body, "&"), }); } @@ -442,11 +490,11 @@ export async function resolveLocalCredentialAuth( Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded", }), - body: [ + body: join([ formEntry("grant_type", "client_credentials"), formEntry("client_id", values[plan.clientIdName]!), formEntry("client_secret", values[plan.clientSecretName]!), - ].join("&"), + ], "&"), }); } diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index d6d9205afd..33bf26182e 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -11,11 +11,41 @@ import type { IntegrationToolMeta } from "./schema.ts"; import { executeLocalIntegrationEndpoint, type LocalIntegrationEndpointTransport, + type LocalIntegrationEndpointTransportRequest, } from "./local-endpoint-executor.ts"; type IntegrationEndpoint = NonNullable; const SECRET = "LOCAL_ENDPOINT_SECRET_MUST_NOT_LEAK"; +const defineProperty = Object.defineProperty; +const deleteProperty = Reflect.deleteProperty; +const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +function appendRestorer(restorers: Array<() => void>, restorer: () => void): void { + defineProperty(restorers, restorers.length, { + configurable: true, + enumerable: true, + value: restorer, + writable: true, + }); +} + +function replaceProperty( + target: object, + key: PropertyKey, + value: unknown, +): () => void { + const descriptor = getOwnPropertyDescriptor(target, key); + defineProperty(target, key, { + configurable: true, + value, + writable: true, + }); + return () => { + if (descriptor) defineProperty(target, key, descriptor); + else deleteProperty(target, key); + }; +} function endpoint(value: IntegrationEndpoint): IntegrationEndpoint { return value; @@ -159,6 +189,85 @@ describe("local integration endpoint executor", () => { assertEquals(result, { ok: true }); }); + it("constructs admitted requests without ambient collection traversal", async () => { + const restorers: Array<() => void> = []; + let poisonCalls = 0; + const poison = (): never => { + poisonCalls += 1; + throw new Error("ambient endpoint primordial used"); + }; + let request: LocalIntegrationEndpointTransportRequest | undefined; + let failure: unknown; + + try { + appendRestorer(restorers, replaceProperty(Array, "isArray", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, Symbol.iterator, poison)); + appendRestorer(restorers, replaceProperty(globalThis, "AbortController", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "clearTimeout", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "encodeURIComponent", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "Headers", poison)); + appendRestorer(restorers, replaceProperty(JSON, "parse", poison)); + appendRestorer(restorers, replaceProperty(JSON, "stringify", poison)); + appendRestorer(restorers, replaceProperty(Number, "isFinite", poison)); + appendRestorer(restorers, replaceProperty(Number, "isSafeInteger", poison)); + appendRestorer(restorers, replaceProperty(Object, "create", poison)); + appendRestorer(restorers, replaceProperty(Object, "defineProperty", poison)); + appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); + appendRestorer(restorers, replaceProperty(Object, "keys", poison)); + appendRestorer(restorers, replaceProperty(Reflect, "getOwnPropertyDescriptor", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "replaceAll", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "setTimeout", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "String", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); + + try { + await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "POST", + url: "https://api.example.test/items", + params: { + limit: { + type: "number", + in: "query", + description: "Page size", + required: true, + }, + }, + body: { + label: { + type: "string", + description: "Label", + required: true, + }, + }, + }), + args: { limit: 2, label: "two" }, + authHeaders: { Authorization: `Bearer ${SECRET}` }, + allowedOrigin: "https://api.example.test", + transport: (nextRequest) => { + request = nextRequest; + throw new Error("stop after request construction"); + }, + }); + } catch (error) { + failure = error; + } + } finally { + for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); + } + + assertEquals(poisonCalls, 0); + assertInstanceOf(failure, VeryfrontError); + assertEquals(failure.slug, "local-integration-request-failed"); + assert(request); + assertEquals(request.url.href, "https://api.example.test/items?limit=2"); + assertEquals(request.init.body, '{"label":"two"}'); + assertEquals(new Headers(request.init.headers).get("authorization"), `Bearer ${SECRET}`); + }); + it("rejects invalid arguments before any transport call", async () => { const requiredEndpoint = endpoint({ method: "GET", @@ -230,6 +339,43 @@ describe("local integration endpoint executor", () => { assert(authorized); }); + it("cleans up rejected provider bodies through captured stream primordials", async () => { + const response = new Response("provider failure", { status: 500 }); + const restorers: Array<() => void> = []; + let poisonCalls = 0; + const poison = (): never => { + poisonCalls += 1; + throw new Error("ambient cleanup primordial used"); + }; + let failure: unknown; + + try { + appendRestorer(restorers, replaceProperty(Promise.prototype, "catch", poison)); + appendRestorer(restorers, replaceProperty(ReadableStream.prototype, "cancel", poison)); + try { + await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/items", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport: () => Promise.resolve(response), + }); + } catch (error) { + failure = error; + } + } finally { + for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); + } + + assertEquals(poisonCalls, 0); + assertInstanceOf(failure, VeryfrontError); + assertEquals(failure.slug, "local-integration-request-failed"); + assertEquals(response.bodyUsed, true); + }); + it("bounds responses and never exposes provider bodies, URLs, headers, or causes", async () => { const fixtures = [ () => new Response(SECRET, { status: 500 }), diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 7549160929..f2cbc6b083 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -18,6 +18,10 @@ type IntegrationEndpointBodyField = NonNullable[str const abortControllerAbort = AbortController.prototype.abort; const AbortControllerConstructor = AbortController; +const abortControllerSignal = Object.getOwnPropertyDescriptor( + AbortController.prototype, + "signal", +)?.get; const abortSignalAborted = Object.getOwnPropertyDescriptor( AbortSignal.prototype, "aborted", @@ -45,9 +49,11 @@ const objectCreate = Object.create; const objectDefineProperty = Object.defineProperty; const objectKeys = Object.keys; const removeEventListener = EventTarget.prototype.removeEventListener; +const readableStreamCancel = ReadableStream.prototype.cancel; const responseBody = Object.getOwnPropertyDescriptor(Response.prototype, "body")?.get; const responseHeaders = Object.getOwnPropertyDescriptor(Response.prototype, "headers")?.get; const responseStatus = Object.getOwnPropertyDescriptor(Response.prototype, "status")?.get; +const promiseCatch = Promise.prototype.catch; const setTimeoutIntrinsic = setTimeout; const StringConstructor = String; const stringCharCodeAt = String.prototype.charCodeAt; @@ -69,6 +75,7 @@ const typedArrayByteLength = Object.getOwnPropertyDescriptor( if ( typeof abortSignalAborted !== "function" || typeof abortSignalReason !== "function" || + typeof abortControllerSignal !== "function" || typeof responseBody !== "function" || typeof responseHeaders !== "function" || typeof responseStatus !== "function" || @@ -156,6 +163,11 @@ function signalValue( return apply(getter, signal, []); } +function controllerSignalValue(controller: AbortController): AbortSignal { + if (!abortControllerSignal) requestFailed(); + return apply(abortControllerSignal, controller, []) as AbortSignal; +} + function responseStatusValue(response: Response): number { if (!responseStatus) requestFailed(); return apply(responseStatus, response, []) as number; @@ -283,7 +295,9 @@ function assertKnownArguments( ): void { const paramNames = objectKeys(endpoint.params ?? {}); const bodyNames = objectKeys(endpoint.body ?? {}); - for (const name of objectKeys(args)) { + const argumentNames = objectKeys(args); + for (let argumentIndex = 0; argumentIndex < argumentNames.length; argumentIndex++) { + const name = argumentNames[argumentIndex]!; let known = false; for (let index = 0; index < paramNames.length; index++) { if (paramNames[index] === name) known = true; @@ -316,7 +330,9 @@ function buildRequest( let endpointUrl = endpoint.url; const headers = new HeadersConstructor(); - for (const name of objectKeys(endpoint.params ?? {})) { + const parameterNames = objectKeys(endpoint.params ?? {}); + for (let index = 0; index < parameterNames.length; index++) { + const name = parameterNames[index]!; const field = endpoint.params?.[name]; if (!field) continue; const resolved = fieldValue(args, name, field); @@ -348,14 +364,17 @@ function buildRequest( if (!urlSearchParams) requestFailed(); const searchParams = apply(urlSearchParams, url, []) as URLSearchParams; - for (const name of objectKeys(endpoint.params ?? {})) { + for (let index = 0; index < parameterNames.length; index++) { + const name = parameterNames[index]!; const field = endpoint.params?.[name]; if (!field || field.in !== "query") continue; const resolved = fieldValue(args, name, field); if (resolved.present) appendQueryValue(searchParams, name, resolved.value, field); } - for (const name of objectKeys(authHeaders)) { + const authHeaderNames = objectKeys(authHeaders); + for (let index = 0; index < authHeaderNames.length; index++) { + const name = authHeaderNames[index]!; const value = ownValue(authHeaders, name); if (!value.present || typeof value.value !== "string") { requestInvalid("Local integration authorization headers are invalid"); @@ -430,7 +449,7 @@ function createRequestSignal( }, timeoutMs); return freeze({ - signal: controller.signal, + signal: controllerSignalValue(controller), release(): void { clearTimeoutIntrinsic(timeoutId); if (signal) apply(removeEventListener, signal, ["abort", abort]); @@ -517,7 +536,11 @@ async function executeTransportRequest( const status = responseStatusValue(response); if (status < 200 || status >= 300) { try { - void responseBodyValue(response)?.cancel().catch(() => undefined); + const body = responseBodyValue(response); + if (body) { + const cancellation = apply(readableStreamCancel, body, []) as Promise; + void apply(promiseCatch, cancellation, [() => undefined]); + } } catch { // Response cleanup is best effort and must not expose provider errors. } @@ -589,7 +612,9 @@ export async function executeLocalIntegrationJsonRequest( requestInvalid("Local integration request origin does not match its admitted origin"); } const headers = new HeadersConstructor(); - for (const name of objectKeys(options.headers)) { + const headerNames = objectKeys(options.headers); + for (let index = 0; index < headerNames.length; index++) { + const name = headerNames[index]!; const value = ownValue(options.headers, name); if (!value.present || typeof value.value !== "string") { requestInvalid("Local integration authorization headers are invalid"); diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 4f8d99680e..ae2a786689 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -19,6 +19,48 @@ import { _createLocalIntegrationToolSourceForTesting } from "./local-tool-source const TEST_CREDENTIAL = "LOCAL_INTEGRATION_SECRET_MUST_NOT_LEAK"; const testCredentialProvider = () => TEST_CREDENTIAL; +const defineProperty = Object.defineProperty; +const deleteProperty = Reflect.deleteProperty; +const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +function replaceProperty( + target: object, + key: PropertyKey, + value: unknown, +): () => void { + const descriptor = getOwnPropertyDescriptor(target, key); + defineProperty(target, key, { + configurable: true, + value, + writable: true, + }); + return () => { + if (descriptor) defineProperty(target, key, descriptor); + else deleteProperty(target, key); + }; +} + +function appendRestorer(restorers: Array<() => void>, restorer: () => void): void { + defineProperty(restorers, restorers.length, { + configurable: true, + enumerable: true, + value: restorer, + writable: true, + }); +} + +function replaceDescriptor( + target: object, + key: PropertyKey, + descriptor: PropertyDescriptor, +): () => void { + const previous = getOwnPropertyDescriptor(target, key); + defineProperty(target, key, descriptor); + return () => { + if (previous) defineProperty(target, key, previous); + else deleteProperty(target, key); + }; +} function headerValue(request: RequestInit, name: string): string | null { return new Headers(request.headers).get(name); @@ -29,6 +71,7 @@ async function assertConfigurationError( expectedDetail: string, ): Promise { const error = await assertRejects(createPromise, VeryfrontError); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-config-invalid"); assert(error.message.includes(expectedDetail), error.message); assertEquals(error.message.includes(TEST_CREDENTIAL), false); @@ -89,6 +132,71 @@ describe("createLocalIntegrationToolSource", () => { ]); }); + it("retains admission semantics after project code mutates ambient primordials", async () => { + _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); + const restorers: Array<() => void> = []; + let poisonCalls = 0; + const poison = (): never => { + poisonCalls += 1; + throw new Error("ambient primordial used"); + }; + let source: ReturnType | undefined; + let definitions: readonly { name: string }[] | undefined; + + try { + appendRestorer(restorers, replaceProperty(Array, "isArray", () => poison())); + appendRestorer(restorers, replaceProperty(Array.prototype, "map", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "push", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "get", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "has", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "set", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "Map", poison)); + appendRestorer(restorers, replaceProperty(Object, "create", poison)); + appendRestorer(restorers, replaceProperty(Object, "defineProperty", poison)); + appendRestorer(restorers, replaceProperty(Object, "entries", poison)); + appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); + appendRestorer(restorers, replaceProperty(Object, "getOwnPropertyDescriptor", poison)); + appendRestorer(restorers, replaceProperty(Object, "values", poison)); + appendRestorer( + restorers, + replaceProperty(Reflect, "getOwnPropertyDescriptor", poison), + ); + appendRestorer(restorers, replaceProperty(Set.prototype, "add", poison)); + appendRestorer(restorers, replaceProperty(Set.prototype, "has", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "Set", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "indexOf", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "lastIndexOf", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "replace", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "startsWith", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); + appendRestorer( + restorers, + replaceDescriptor(Array.prototype, "0", { + configurable: true, + set: poison, + }), + ); + + source = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + definitions = await source.listTools(); + } finally { + for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); + } + + assertEquals(poisonCalls, 0); + assert(source); + assert(Object.isFrozen(source)); + assertEquals(definitions?.map((definition) => definition.name), [ + "vercel__list_projects", + ]); + }); + it("validates configured credential names before exposing tools", async () => { const calls: string[] = []; const source = createLocalIntegrationToolSource({ @@ -101,6 +209,7 @@ describe("createLocalIntegrationToolSource", () => { const error = await assertRejects(() => source.listTools(), VeryfrontError); assertEquals(calls, ["SENDCLOUD_PUBLIC_KEY", "SENDCLOUD_SECRET_KEY"]); + assertInstanceOf(error, VeryfrontError); assertEquals(error.slug, "local-integration-credentials-missing"); assertEquals(error.message.includes("SENDCLOUD_SECRET_KEY"), true); assertEquals(error.message.includes("public-key"), false); diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index b524b20026..8c725b706c 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -22,6 +22,31 @@ import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; import { parseIntegrationToolIdentity } from "./source-policy.ts"; import type { IntegrationConfig, IntegrationToolMeta } from "./schema.ts"; +const apply = Reflect.apply; +const arrayIsArray = Array.isArray; +const freeze = Object.freeze; +const getOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor; +const MapConstructor = Map; +const mapGet = Map.prototype.get; +const mapHas = Map.prototype.has; +const mapSet = Map.prototype.set; +const objectDefineProperty = Object.defineProperty; +const objectEntries = Object.entries; +const objectValues = Object.values; +const SetConstructor = Set; +const setAdd = Set.prototype.add; +const setHas = Set.prototype.has; +const stringIncludes = String.prototype.includes; +const stringReplace = String.prototype.replace; +const stringStartsWith = String.prototype.startsWith; +const URLConstructor = URL; +const urlHash = Object.getOwnPropertyDescriptor(URL.prototype, "hash")?.get; +const urlHostname = Object.getOwnPropertyDescriptor(URL.prototype, "hostname")?.get; +const urlOrigin = Object.getOwnPropertyDescriptor(URL.prototype, "origin")?.get; +const urlPassword = Object.getOwnPropertyDescriptor(URL.prototype, "password")?.get; +const urlProtocol = Object.getOwnPropertyDescriptor(URL.prototype, "protocol")?.get; +const urlUsername = Object.getOwnPropertyDescriptor(URL.prototype, "username")?.get; + /** Resolve one local integration credential by its canonical environment-variable name. */ export type LocalIntegrationCredentialProvider = ( environmentVariableName: string, @@ -46,6 +71,32 @@ interface AdmittedLocalIntegrationTool { readonly definition: ToolDefinition; } +function append(values: T[], value: T): void { + objectDefineProperty(values, values.length, { + configurable: true, + enumerable: true, + value, + writable: true, + }); +} + +function stringBoolean( + operation: (this: string, search: string) => boolean, + value: string, + search: string, +): boolean { + return apply(operation, value, [search]); +} + +function urlValue(getter: ((this: URL) => string) | undefined, url: URL): string { + if (!getter) configurationError("URL parsing is unavailable in this runtime"); + return apply(getter, url, []); +} + +function mapValue(map: Map, key: K): V | undefined { + return apply(mapGet, map, [key]) as V | undefined; +} + function configurationError(detail: string): never { return localIntegrationConfigurationError(detail); } @@ -54,7 +105,7 @@ function readOwnDataProperty( value: LocalIntegrationToolSourceOptions | readonly unknown[], key: PropertyKey, ): { present: boolean; value: unknown } { - const descriptor = Reflect.getOwnPropertyDescriptor(value, key); + const descriptor = getOwnPropertyDescriptor(value, key); if (!descriptor) return { present: false, value: undefined }; if (!("value" in descriptor)) { configurationError(`Local integration option "${String(key)}" must be a data property`); @@ -66,12 +117,12 @@ function snapshotOptions(options: LocalIntegrationToolSourceOptions): { tools: readonly string[]; credentialProvider: LocalIntegrationCredentialProvider | undefined; } { - if (typeof options !== "object" || options === null || Array.isArray(options)) { + if (typeof options !== "object" || options === null || arrayIsArray(options)) { configurationError("Local integration options must be an object"); } const toolsValue = readOwnDataProperty(options, "tools").value; - if (!Array.isArray(toolsValue)) { + if (!arrayIsArray(toolsValue)) { configurationError("Local integration tools must be an array of canonical tool IDs"); } if (toolsValue.length === 0) { @@ -89,7 +140,7 @@ function snapshotOptions(options: LocalIntegrationToolSourceOptions): { if (!item.present || typeof item.value !== "string") { configurationError("Local integration tools must contain only canonical string IDs"); } - tools.push(item.value); + append(tools, item.value); } const providerValue = readOwnDataProperty(options, "credentialProvider"); @@ -101,7 +152,7 @@ function snapshotOptions(options: LocalIntegrationToolSourceOptions): { } return { - tools: Object.freeze(tools), + tools: freeze(tools), credentialProvider: providerValue.value as LocalIntegrationCredentialProvider | undefined, }; } @@ -128,7 +179,7 @@ function catalogTool( if (typeof tool?.name !== "string" || typeof tool.description !== "string") { configurationError(`Local integration tool "${canonicalToolId}" has invalid metadata`); } - return Object.freeze({ + return freeze({ ...tool, id: canonicalToolId, name: tool.name, @@ -142,17 +193,20 @@ function catalogTool( function assertHttpsCatalogUrl(value: string, label: string): string { let parsed: URL; try { - parsed = new URL(value); + parsed = new URLConstructor(value); } catch { configurationError(`${label} must be a fixed HTTPS URL`); } if ( - parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || - value.includes("{{") || parsed.hostname.includes("{") || parsed.hostname.includes("}") + urlValue(urlProtocol, parsed) !== "https:" || urlValue(urlUsername, parsed) !== "" || + urlValue(urlPassword, parsed) !== "" || urlValue(urlHash, parsed) !== "" || + stringBoolean(stringIncludes, value, "{{") || + stringBoolean(stringIncludes, urlValue(urlHostname, parsed), "{") || + stringBoolean(stringIncludes, urlValue(urlHostname, parsed), "}") ) { configurationError(`${label} must be a fixed HTTPS URL without credentials`); } - return parsed.origin; + return urlValue(urlOrigin, parsed); } function assertSupportedAuth( @@ -163,7 +217,10 @@ function assertSupportedAuth( if (connector.name === "salesforce") return; if (auth.type === "api-key") { - if (auth.queryParamName || endpoint.url.includes("{{auth.token}}")) { + if ( + auth.queryParamName || + stringBoolean(stringIncludes, endpoint.url, "{{auth.token}}") + ) { configurationError( `Local integration "${connector.name}" uses query or URL credentials, ` + "which are unsupported", @@ -209,14 +266,16 @@ function assertSupportedEndpoint( if (endpoint.bodyMode === "form-data" || endpoint.bodyMode === "raw") { configurationError(`Local integration tool "${toolId}" uses an unsupported body mode`); } - for (const field of Object.values(endpoint.body ?? {})) { + const bodyFields = objectValues(endpoint.body ?? {}); + for (let index = 0; index < bodyFields.length; index++) { + const field = bodyFields[index]!; if (field.encoding || field.partFilenameField) { configurationError(`Local integration tool "${toolId}" uses an unsupported encoded body`); } } if (connector.name === "salesforce") { - if (!endpoint.url.startsWith("{{oauth.raw.instance_url}}/")) { + if (!stringBoolean(stringStartsWith, endpoint.url, "{{oauth.raw.instance_url}}/")) { configurationError(`Local Salesforce tool "${toolId}" has an unsupported endpoint template`); } return undefined; @@ -260,25 +319,29 @@ function toolDefinition( const properties: Record = {}; const required: string[] = []; - for (const [name, parameter] of Object.entries(endpoint.params ?? {})) { + const parameterEntries = objectEntries(endpoint.params ?? {}); + for (let index = 0; index < parameterEntries.length; index++) { + const [name, parameter] = parameterEntries[index]!; properties[name] = inputPropertySchema(parameter); - if (parameter.required) required.push(name); + if (parameter.required) append(required, name); } - for (const [name, field] of Object.entries(endpoint.body ?? {})) { + const bodyEntries = objectEntries(endpoint.body ?? {}); + for (let index = 0; index < bodyEntries.length; index++) { + const [name, field] = bodyEntries[index]!; if (properties[name]) { configurationError(`Local integration tool "${tool.id}" declares duplicate input "${name}"`); } properties[name] = inputPropertySchema(field); - if (field.required) required.push(name); + if (field.required) append(required, name); } - return Object.freeze({ + return freeze({ name: tool.id, description: tool.description, - parameters: Object.freeze({ + parameters: freeze({ type: "object", - properties: Object.freeze(properties), - required: Object.freeze(required), + properties: freeze(properties), + required: freeze(required), additionalProperties: false, }) as JsonSchema, }); @@ -308,7 +371,7 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { canonicalToolId, ); assertSupportedAuth(connector, tool.endpoint); - return Object.freeze({ + return freeze({ authPlan: createLocalCredentialAuthPlan(connector), connector, endpoint: tool.endpoint, @@ -332,28 +395,34 @@ function createLocalIntegrationToolSourceInternal( transport?: LocalIntegrationEndpointTransport, ): RemoteToolSource { const snapshot = snapshotOptions(options); - const admitted = new Map(); + const admitted = new MapConstructor(); const credentialProvider = snapshot.credentialProvider ?? getEnv; - for (const toolId of snapshot.tools) { - if (admitted.has(toolId)) { + for (let index = 0; index < snapshot.tools.length; index++) { + const toolId = snapshot.tools[index]!; + if (apply(mapHas, admitted, [toolId])) { configurationError(`Local integration tool "${toolId}" is a duplicate grant`); } - admitted.set(toolId, admitTool(toolId)); + apply(mapSet, admitted, [toolId, admitTool(toolId)]); } - return Object.freeze({ + return freeze({ id: "veryfront-local-integrations", async listTools(): Promise { assertLocalRuntime(); - const validatedConnectors = new Set(); - for (const toolId of snapshot.tools) { - const tool = admitted.get(toolId)!; - if (validatedConnectors.has(tool.connector.name)) continue; + const validatedConnectors = new SetConstructor(); + for (let index = 0; index < snapshot.tools.length; index++) { + const toolId = snapshot.tools[index]!; + const tool = mapValue(admitted, toolId)!; + if (apply(setHas, validatedConnectors, [tool.connector.name])) continue; await resolveLocalCredentialAuth(tool.authPlan, credentialProvider); - validatedConnectors.add(tool.connector.name); + apply(setAdd, validatedConnectors, [tool.connector.name]); + } + const definitions: ToolDefinition[] = []; + for (let index = 0; index < snapshot.tools.length; index++) { + append(definitions, mapValue(admitted, snapshot.tools[index]!)!.definition); } - return snapshot.tools.map((toolId) => admitted.get(toolId)!.definition); + return definitions; }, async executeTool( toolName: string, @@ -361,7 +430,7 @@ function createLocalIntegrationToolSourceInternal( context?: ToolExecutionContext, ): Promise { assertLocalRuntime(); - const tool = admitted.get(toolName); + const tool = mapValue(admitted, toolName); if (!tool) { configurationError(`Local integration tool "${toolName}" is not granted by this source`); } @@ -376,12 +445,12 @@ function createLocalIntegrationToolSourceInternal( if (!auth.instanceOrigin) { configurationError("Local Salesforce execution requires a validated instance origin"); } - endpoint = Object.freeze({ + endpoint = freeze({ ...endpoint, - url: endpoint.url.replace( + url: apply(stringReplace, endpoint.url, [ "{{oauth.raw.instance_url}}", auth.instanceOrigin, - ), + ]) as string, }); allowedOrigin = auth.instanceOrigin; } diff --git a/src/integrations/source-policy.ts b/src/integrations/source-policy.ts index aa66280b7f..1eb1fe0b8e 100644 --- a/src/integrations/source-policy.ts +++ b/src/integrations/source-policy.ts @@ -9,6 +9,12 @@ import type { IntegrationName } from "./schema.ts"; +const apply = Reflect.apply; +const stringCharCodeAt = String.prototype.charCodeAt; +const stringIndexOf = String.prototype.indexOf; +const stringLastIndexOf = String.prototype.lastIndexOf; +const stringSlice = String.prototype.slice; + export interface SourceIntegrationRestriction { /** * Exact connector-local tool IDs. Omit to allow every catalog tool for the @@ -230,25 +236,52 @@ export interface IntegrationToolIdentity { toolId: string; } +function canonicalToolSegment(value: string): boolean { + if (value.length === 0) return false; + for (let index = 0; index < value.length; index++) { + const code = apply(stringCharCodeAt, value, [index]) as number; + const allowed = code >= 97 && code <= 122 || code >= 48 && code <= 57 || + (index > 0 && (code === 45 || code === 95)); + if (!allowed) return false; + } + return true; +} + +function stringIndex( + operation: (this: string, search: string) => number, + value: string, + search: string, +): number { + return apply(operation, value, [search]); +} + +function slice(value: string, start: number, end?: number): string { + return end === undefined + ? apply(stringSlice, value, [start]) + : apply(stringSlice, value, [start, end]); +} + /** * Parse the canonical API tool name (`integration__tool_id`). Aliases and * alternate separators are intentionally not accepted at this policy layer. */ export function parseIntegrationToolIdentity(toolName: string): IntegrationToolIdentity | null { - const separator = toolName.indexOf("__"); + const separator = stringIndex(stringIndexOf, toolName, "__"); if ( separator <= 0 || - separator !== toolName.lastIndexOf("__") || - separator + 2 >= toolName.length || - !CANONICAL_INTEGRATION_TOOL_SEGMENT.test(toolName.slice(0, separator)) || - !CANONICAL_INTEGRATION_TOOL_SEGMENT.test(toolName.slice(separator + 2)) + separator !== stringIndex(stringLastIndexOf, toolName, "__") || + separator + 2 >= toolName.length ) { return null; } + const integration = slice(toolName, 0, separator); + const toolId = slice(toolName, separator + 2); + if (!canonicalToolSegment(integration) || !canonicalToolSegment(toolId)) return null; + return { - integration: toolName.slice(0, separator), - toolId: toolName.slice(separator + 2), + integration, + toolId, }; } From 58b499c7e0d3511e7f5906d6b692c0f472a0f1e2 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 06:05:06 +0200 Subject: [PATCH 09/25] Keep local integration credentials bound to trusted catalog metadata Review hardening captures credential-bearing catalog data before project code can mutate public exports, keeps credential identifiers out of model-visible definitions, reports only bounded provider diagnostics, and carries required Basic-auth headers. Constraint: Local credential values and credential identifiers must never enter model metadata or provider diagnostics Rejected: Re-read the mutable public connector catalog | project code can mutate it before source construction Confidence: high Scope-risk: narrow Directive: Keep local admission on the private catalog snapshot and preserve exact-grant semantics Tested: 15-suite integration and tool matrix (39 tests, 245 steps); docs validation; pinned API docs; npm build --- docs/api-reference/veryfront/integrations.md | 6 +- docs/guides/integrations.md | 2 +- docs/guides/self-hosting.md | 20 +-- .../local-credential-auth.test.ts | 37 +++++ src/integrations/local-credential-auth.ts | 146 ++++++++++++++--- .../local-endpoint-executor.test.ts | 40 ++++- src/integrations/local-endpoint-executor.ts | 87 +++++++--- src/integrations/local-integration-errors.ts | 50 ++++++ src/integrations/local-tool-source.test.ts | 54 +++++- src/integrations/local-tool-source.ts | 155 ++++++++++++++---- 10 files changed, 486 insertions(+), 111 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index e328810d30..a685d42146 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -54,7 +54,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L473) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L558) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | | `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | @@ -76,8 +76,8 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | | `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | | `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L51) | -| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L56) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L53) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L58) | | `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | | `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | | `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | diff --git a/docs/guides/integrations.md b/docs/guides/integrations.md index 5b1604e377..9682b01199 100644 --- a/docs/guides/integrations.md +++ b/docs/guides/integrations.md @@ -21,7 +21,7 @@ inventory records credential readiness independently of all three. ## Run account-free local integration tools -Use the catalog-backed local source when a local or self-hosted project should +Use the catalog-backed local source when a local or self-hosted project needs to call supported REST integrations without a Veryfront account or project token: ```ts diff --git a/docs/guides/self-hosting.md b/docs/guides/self-hosting.md index b51e6e687f..47baac2949 100644 --- a/docs/guides/self-hosting.md +++ b/docs/guides/self-hosting.md @@ -18,16 +18,16 @@ environment. Self-hosting does not require a Veryfront account. Choose substitutes for managed capabilities before you deploy. -| Capability | Self-hosted support | Requirement | -| ------------------------------------------ | --------------------------------------- | ----------------------------------------------------------------------------- | -| Pages, API routes, AG-UI, tools, and MCP | Supported | Run the project with `veryfront serve`. | -| Direct provider inference | Supported | Set the selected provider key or configure an OpenAI-compatible endpoint. | -| Local agent delegation with `delegates` | Supported | Delegates run in the application process. | -| Workflows | Supported | Use the in-memory backend or configure Redis for shared durable state. | -| Source-controlled project knowledge | Supported | Use the local project directory and the project knowledge tools. | -| Remote integration tools | Supported subset | Use a local source or managed backing API. | -| Sandbox sessions | Requires a backing API or service layer | Configure authenticated sandbox session APIs. | -| Veryfront Cloud routing, storage, and runs | Requires Veryfront Cloud | These capabilities depend on project and control-plane context. | +| Capability | Self-hosted support | Requirement | +| ------------------------------------------ | --------------------------------------- | ------------------------------------------------------------------------- | +| Pages, API routes, AG-UI, tools, and MCP | Supported | Run the project with `veryfront serve`. | +| Direct provider inference | Supported | Set the selected provider key or configure an OpenAI-compatible endpoint. | +| Local agent delegation with `delegates` | Supported | Delegates run in the application process. | +| Workflows | Supported | Use the in-memory backend or configure Redis for shared durable state. | +| Source-controlled project knowledge | Supported | Use the local project directory and the project knowledge tools. | +| Remote integration tools | Supported subset | Use a local source or managed backing API. | +| Sandbox sessions | Requires a backing API or service layer | Configure authenticated sandbox session APIs. | +| Veryfront Cloud routing, storage, and runs | Requires Veryfront Cloud | These capabilities depend on project and control-plane context. | For supported fixed REST tools, create a local source with the exact canonical tool IDs the application grants: diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index 0c5c4b15a8..589f8dffae 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -118,6 +118,27 @@ describe("local integration credential auth", () => { assertEquals(JSON.stringify(plan).includes(SECRET), false); }); + it("adds catalog-declared headers to HTTP Basic requests", async () => { + const plan = createLocalCredentialAuthPlan(connector("billbee")); + + assertEquals(plan.requiredEnvironmentVariables, [ + "BILLBEE_USERNAME", + "BILLBEE_API_PASSWORD", + "BILLBEE_API_KEY", + ]); + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + BILLBEE_USERNAME: "ada@example.test", + BILLBEE_API_PASSWORD: SECRET, + BILLBEE_API_KEY: "billbee-application-key", + }), + ); + + assertEquals(resolved.kind, "headers"); + assertEquals(resolved.headers["X-Billbee-Api-Key"], "billbee-application-key"); + }); + it("builds a PayPal client-credentials token request", async () => { const plan = createLocalCredentialAuthPlan(connector("paypal")); assertEquals(plan.requiredEnvironmentVariables, [ @@ -260,6 +281,22 @@ describe("local integration credential auth", () => { assertEquals(error.cause, undefined); }); + it("sorts missing credential variable names in configuration errors", async () => { + const plan = createLocalCredentialAuthPlan(connector("billbee")); + + const error = await assertRejects( + () => resolveLocalCredentialAuth(plan, () => undefined), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-credentials-missing"); + assert( + error.message.includes("BILLBEE_API_KEY, BILLBEE_API_PASSWORD, BILLBEE_USERNAME"), + error.message, + ); + }); + it("fails safely for invalid values, provider failures, and Salesforce login URLs", async () => { const plan = createLocalCredentialAuthPlan(connector("vercel")); for (const value of ["", " ", "x".repeat(16_385)]) { diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index f96e2aef03..357c56a659 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -3,8 +3,8 @@ import type { IntegrationConfig } from "./schema.ts"; import { LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, LOCAL_INTEGRATION_CREDENTIALS_MISSING, - LOCAL_INTEGRATION_RESPONSE_INVALID, localIntegrationConfigurationError, + localIntegrationResponseInvalid, } from "./local-integration-errors.ts"; import { executeLocalIntegrationJsonRequest, @@ -59,6 +59,7 @@ interface LocalBasicAuthPlan extends LocalCredentialAuthPlanBase { readonly usernameName: string; readonly passwordName: string; readonly passwordFallback?: string; + readonly additionalHeaders: Readonly>; } interface LocalClientCredentialsAuthPlan extends LocalCredentialAuthPlanBase { @@ -135,6 +136,41 @@ function join(values: readonly string[], separator: string): string { return apply(arrayJoin, values, [separator]) as string; } +function compareStrings(left: string, right: string): number { + const length = left.length < right.length ? left.length : right.length; + for (let index = 0; index < length; index++) { + const leftCode = apply(stringCharCodeAt, left, [index]) as number; + const rightCode = apply(stringCharCodeAt, right, [index]) as number; + if (leftCode !== rightCode) return leftCode - rightCode; + } + return left.length - right.length; +} + +function sortStrings(values: string[]): void { + for (let index = 1; index < values.length; index++) { + const value = values[index]!; + let insertionIndex = index; + while ( + insertionIndex > 0 && + compareStrings(values[insertionIndex - 1]!, value) > 0 + ) { + objectDefineProperty(values, insertionIndex, { + configurable: true, + enumerable: true, + value: values[insertionIndex - 1], + writable: true, + }); + insertionIndex -= 1; + } + objectDefineProperty(values, insertionIndex, { + configurable: true, + enumerable: true, + value, + writable: true, + }); + } +} + function urlValue(getter: ((this: URL) => string) | undefined, url: URL): string { if (!getter) localIntegrationConfigurationError("URL parsing is unavailable in this runtime"); return apply(getter, url, []); @@ -172,7 +208,10 @@ function normalizedConnectorPrefix(name: string): string { return prefix; } -function declaredFallback(connector: IntegrationConfig, name: string): string | undefined { +function declaredFallback( + connector: Pick, + name: string, +): string | undefined { for (let index = 0; index < (connector.envVars?.length ?? 0); index++) { const envVar = connector.envVars?.[index]; if (envVar?.name !== name) continue; @@ -184,7 +223,7 @@ function declaredFallback(connector: IntegrationConfig, name: string): string | /** Build a serializable, value-free credential plan from trusted catalog metadata. */ export function createLocalCredentialAuthPlan( - connector: IntegrationConfig, + connector: Pick, ): LocalCredentialAuthPlan { const auth = connector.auth; if (connector.name === "salesforce") { @@ -236,13 +275,20 @@ export function createLocalCredentialAuthPlan( `Local integration "${connector.name}" is missing Basic credential names`, ); } + const additionalHeaders = freeze({ ...auth.additionalHeaders }); + const required = [auth.usernameKey, auth.passwordKey]; + const additionalNames = objectValues(additionalHeaders); + for (let index = 0; index < additionalNames.length; index++) { + append(required, additionalNames[index]!); + } return freeze({ kind: "basic", connectorName: connector.name, usernameName: auth.usernameKey, passwordName: auth.passwordKey, passwordFallback: declaredFallback(connector, auth.passwordKey), - requiredEnvironmentVariables: freeze([auth.usernameKey, auth.passwordKey]), + additionalHeaders, + requiredEnvironmentVariables: freeze(required), }); } @@ -358,6 +404,7 @@ async function readCredentials( } } if (missing.length > 0) { + sortStrings(missing); throw LOCAL_INTEGRATION_CREDENTIALS_MISSING.create({ detail: `Set local integration credential variables: ${join(missing, ", ")}`, }); @@ -398,31 +445,43 @@ function normalizeSalesforceLoginUrl(value: string): string { return origin; } -function tokenResponseInvalid(): never { - throw LOCAL_INTEGRATION_RESPONSE_INVALID.create(); +function tokenResponseInvalid( + connectorName: string, + toolId: string, + status: number, +): never { + return localIntegrationResponseInvalid({ connectorName, toolId }, status); } function tokenResponseString( value: Record, key: string, + connectorName: string, + toolId: string, + status: number, ): string { const descriptor = getOwnPropertyDescriptor(value, key); if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "string") { - tokenResponseInvalid(); + tokenResponseInvalid(connectorName, toolId, status); } const result = descriptor.value; if ( stringCall(stringTrim, result).length === 0 || result.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH ) { - tokenResponseInvalid(); + tokenResponseInvalid(connectorName, toolId, status); } return result; } -function tokenResponseRecord(value: unknown): Record { +function tokenResponseRecord( + value: unknown, + connectorName: string, + toolId: string, + status: number, +): Record { if (typeof value !== "object" || value === null || arrayIsArray(value)) { - tokenResponseInvalid(); + tokenResponseInvalid(connectorName, toolId, status); } return value as Record; } @@ -448,10 +507,17 @@ export async function resolveLocalCredentialAuth( if (plan.kind === "basic") { const credential = `${values[plan.usernameName]!}:${values[plan.passwordName]!}`; + const headers: Record = objectCreate(null); + headers.Authorization = `Basic ${base64(credential)}`; + const additionalEntries = objectEntries(plan.additionalHeaders); + for (let index = 0; index < additionalEntries.length; index++) { + const [headerName, environmentName] = additionalEntries[index]!; + headers[headerName] = values[environmentName]!; + } return freeze({ kind: "headers", connectorName: plan.connectorName, - headers: freeze({ Authorization: `Basic ${base64(credential)}` }), + headers: freeze(headers), }); } @@ -501,6 +567,7 @@ export async function resolveLocalCredentialAuth( /** Mint a short-lived bearer credential from a previously resolved local auth request. */ export async function mintLocalCredentialAuth( resolved: ResolvedLocalCredentialAuth, + toolId: string, signal?: AbortSignal, transport?: LocalIntegrationEndpointTransport, ): Promise { @@ -510,20 +577,43 @@ export async function mintLocalCredentialAuth( const tokenUrl = parseUrl(resolved.url, "Local integration token URL"); const tokenOrigin = urlValue(urlOrigin, tokenUrl); + const tokenResult = await executeLocalIntegrationJsonRequest({ + connectorName: resolved.connectorName, + toolId, + url: resolved.url, + method: "POST", + headers: resolved.headers, + body: resolved.body, + allowedOrigin: tokenOrigin, + signal, + transport, + }); const response = tokenResponseRecord( - await executeLocalIntegrationJsonRequest({ - url: resolved.url, - method: "POST", - headers: resolved.headers, - body: resolved.body, - allowedOrigin: tokenOrigin, - signal, - transport, - }), + tokenResult.value, + resolved.connectorName, + toolId, + tokenResult.status, ); - const accessToken = tokenResponseString(response, "access_token"); - const tokenType = stringCall(stringToLowerCase, tokenResponseString(response, "token_type")); - if (tokenType !== "bearer") tokenResponseInvalid(); + const accessToken = tokenResponseString( + response, + "access_token", + resolved.connectorName, + toolId, + tokenResult.status, + ); + const tokenType = stringCall( + stringToLowerCase, + tokenResponseString( + response, + "token_type", + resolved.connectorName, + toolId, + tokenResult.status, + ), + ); + if (tokenType !== "bearer") { + tokenResponseInvalid(resolved.connectorName, toolId, tokenResult.status); + } const headers = freeze({ Authorization: `Bearer ${accessToken}` }); if (resolved.mode === "client-credentials") return freeze({ headers }); @@ -531,7 +621,13 @@ export async function mintLocalCredentialAuth( return freeze({ headers, instanceOrigin: parseSalesforceOrigin( - tokenResponseString(response, "instance_url"), - ) ?? tokenResponseInvalid(), + tokenResponseString( + response, + "instance_url", + resolved.connectorName, + toolId, + tokenResult.status, + ), + ) ?? tokenResponseInvalid(resolved.connectorName, toolId, tokenResult.status), }); } diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index 33bf26182e..0e09354e43 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -9,7 +9,8 @@ import { import { describe, it } from "#veryfront/testing/bdd.ts"; import type { IntegrationToolMeta } from "./schema.ts"; import { - executeLocalIntegrationEndpoint, + executeLocalIntegrationEndpoint as executeEndpoint, + type ExecuteLocalIntegrationEndpointOptions, type LocalIntegrationEndpointTransport, type LocalIntegrationEndpointTransportRequest, } from "./local-endpoint-executor.ts"; @@ -51,6 +52,18 @@ function endpoint(value: IntegrationEndpoint): IntegrationEndpoint { return value; } +function executeLocalIntegrationEndpoint( + options: + & Omit + & Partial>, +): Promise { + return executeEndpoint({ + ...options, + connectorName: options.connectorName ?? "example", + toolId: options.toolId ?? "example__test", + }); +} + describe("local integration endpoint executor", () => { it( "builds a bounded REST request from catalog path, query, header, and body fields", @@ -378,18 +391,23 @@ describe("local integration endpoint executor", () => { it("bounds responses and never exposes provider bodies, URLs, headers, or causes", async () => { const fixtures = [ - () => new Response(SECRET, { status: 500 }), - () => new Response(`{"secret":"${SECRET}"`, { status: 200 }), - () => - new Response("{}", { - headers: { "content-length": String(4 * 1024 * 1024 + 1) }, - }), + { response: () => new Response(SECRET, { status: 500 }), status: 500 }, + { response: () => new Response(`{"secret":"${SECRET}"`, { status: 200 }), status: 200 }, + { + response: () => + new Response("{}", { + headers: { "content-length": String(4 * 1024 * 1024 + 1) }, + }), + status: 200, + }, ]; - for (const response of fixtures) { + for (const fixture of fixtures) { const error = await assertRejects( () => executeLocalIntegrationEndpoint({ + connectorName: "example", + toolId: "example__list_items", endpoint: endpoint({ method: "GET", url: `https://api.example.test/items?credential=${SECRET}`, @@ -397,7 +415,7 @@ describe("local integration endpoint executor", () => { args: {}, authHeaders: { Authorization: `Bearer ${SECRET}` }, allowedOrigin: "https://api.example.test", - transport: () => Promise.resolve(response()), + transport: () => Promise.resolve(fixture.response()), }), VeryfrontError, ); @@ -406,7 +424,11 @@ describe("local integration endpoint executor", () => { error.slug === "local-integration-request-failed" || error.slug === "local-integration-response-invalid", ); + assert(error.message.includes('integration "example"'), error.message); + assert(error.message.includes('tool "example__list_items"'), error.message); + assert(error.message.includes(`HTTP status ${fixture.status}`), error.message); assertEquals(error.message.includes(SECRET), false); + assertEquals(error.message.includes("api.example.test"), false); assertEquals(error.cause, undefined); } }); diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index f2cbc6b083..566edecacb 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -2,9 +2,10 @@ import { snapshotBoundedJsonValue } from "#veryfront/schemas/json-value.ts"; import { guardedEgressFetch } from "#veryfront/security/sandbox/worker-egress-guard.ts"; import { readResponseTextPrefix } from "#veryfront/utils/response-body.ts"; import { - LOCAL_INTEGRATION_REQUEST_FAILED, LOCAL_INTEGRATION_REQUEST_INVALID, - LOCAL_INTEGRATION_RESPONSE_INVALID, + type LocalIntegrationDiagnosticIdentity, + localIntegrationRequestFailed, + localIntegrationResponseInvalid, } from "./local-integration-errors.ts"; import { INTEGRATION_REQUEST_TIMEOUT_MS, @@ -98,7 +99,7 @@ export type LocalIntegrationEndpointTransport = ( request: LocalIntegrationEndpointTransportRequest, ) => Promise; -export interface ExecuteLocalIntegrationEndpointOptions { +export interface ExecuteLocalIntegrationEndpointOptions extends LocalIntegrationDiagnosticIdentity { readonly endpoint: IntegrationEndpoint; readonly args: Record; readonly authHeaders: Readonly>; @@ -110,7 +111,8 @@ export interface ExecuteLocalIntegrationEndpointOptions { readonly transport?: LocalIntegrationEndpointTransport; } -export interface ExecuteLocalIntegrationJsonRequestOptions { +export interface ExecuteLocalIntegrationJsonRequestOptions + extends LocalIntegrationDiagnosticIdentity { readonly url: string; readonly method: "POST"; readonly headers: Readonly>; @@ -121,6 +123,11 @@ export interface ExecuteLocalIntegrationJsonRequestOptions { readonly transport?: LocalIntegrationEndpointTransport; } +export interface LocalIntegrationJsonResult { + readonly status: number; + readonly value: unknown; +} + interface RequestSignalLease { readonly signal: AbortSignal; release(): void; @@ -130,12 +137,18 @@ function requestInvalid(detail: string): never { throw LOCAL_INTEGRATION_REQUEST_INVALID.create({ detail }); } -function requestFailed(): never { - throw LOCAL_INTEGRATION_REQUEST_FAILED.create(); +function requestFailed( + identity?: LocalIntegrationDiagnosticIdentity, + status?: number, +): never { + return localIntegrationRequestFailed(identity, status); } -function responseInvalid(): never { - throw LOCAL_INTEGRATION_RESPONSE_INVALID.create(); +function responseInvalid( + identity?: LocalIntegrationDiagnosticIdentity, + status?: number, +): never { + return localIntegrationResponseInvalid(identity, status); } function callStringBoolean( @@ -461,7 +474,7 @@ const guardedTransport: LocalIntegrationEndpointTransport = async (request) => { return await guardedEgressFetch(request.url, request.init, { authorizeUrl(url): void { if (urlValue(urlOrigin, url) !== request.allowedOrigin) { - throw LOCAL_INTEGRATION_REQUEST_FAILED.create(); + requestFailed(); } }, }); @@ -491,8 +504,13 @@ function decodedByteLength(value: string): number { return apply(typedArrayByteLength, encoded, []) as number; } -async function readResponseJson(response: Response, signal: AbortSignal): Promise { - if (!contentLengthWithinLimit(response)) responseInvalid(); +async function readResponseJson( + response: Response, + signal: AbortSignal, + identity: LocalIntegrationDiagnosticIdentity, + status: number, +): Promise { + if (!contentLengthWithinLimit(response)) responseInvalid(identity, status); let text: string; let truncated: boolean; try { @@ -503,22 +521,22 @@ async function readResponseJson(response: Response, signal: AbortSignal): Promis { fatalUtf8: true }, )); } catch { - responseInvalid(); + responseInvalid(identity, status); } if ( truncated || decodedByteLength(text) > MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES ) { - responseInvalid(); + responseInvalid(identity, status); } let parsed: unknown; try { parsed = jsonParse(text); } catch { - responseInvalid(); + responseInvalid(identity, status); } const snapshot = snapshotBoundedJsonValue(parsed); - if (!snapshot.success) responseInvalid(); + if (!snapshot.success) responseInvalid(identity, status); return snapshot.value; } @@ -526,12 +544,13 @@ async function executeTransportRequest( request: LocalIntegrationEndpointTransportRequest, transport: LocalIntegrationEndpointTransport, signal: AbortSignal, -): Promise { + identity: LocalIntegrationDiagnosticIdentity, +): Promise<{ readonly status: number; readonly value: unknown }> { let response: Response; try { response = await transport(request); } catch { - requestFailed(); + requestFailed(identity); } const status = responseStatusValue(response); if (status < 200 || status >= 300) { @@ -544,21 +563,29 @@ async function executeTransportRequest( } catch { // Response cleanup is best effort and must not expose provider errors. } - requestFailed(); + requestFailed(identity, status); } - return await readResponseJson(response, signal); + return freeze({ + status, + value: await readResponseJson(response, signal, identity, status), + }); } -function transformResponse(value: unknown, transform: string | undefined): unknown { +function transformResponse( + value: unknown, + transform: string | undefined, + identity: LocalIntegrationDiagnosticIdentity, + status: number, +): unknown { if (transform === undefined || transform === "") return value; let current = value; let start = 0; for (let index = 0; index <= transform.length; index++) { if (index < transform.length && charCodeAt(transform, index) !== 46) continue; const segment = slice(transform, start, index); - if (segment === "" || !isRecord(current)) responseInvalid(); + if (segment === "" || !isRecord(current)) responseInvalid(identity, status); const next = ownValue(current, segment); - if (!next.present) responseInvalid(); + if (!next.present) responseInvalid(identity, status); current = next.value; start = index + 1; } @@ -582,12 +609,18 @@ export async function executeLocalIntegrationEndpoint( options.allowedOrigin, signalLease.signal, ); - const value = await executeTransportRequest( + const result = await executeTransportRequest( request, options.transport ?? guardedTransport, signalLease.signal, + options, + ); + return transformResponse( + result.value, + options.endpoint.response?.transform, + options, + result.status, ); - return transformResponse(value, options.endpoint.response?.transform); } finally { signalLease.release(); } @@ -596,7 +629,7 @@ export async function executeLocalIntegrationEndpoint( /** Execute one fixed-origin JSON request, including OAuth token requests. */ export async function executeLocalIntegrationJsonRequest( options: ExecuteLocalIntegrationJsonRequestOptions, -): Promise { +): Promise { const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, @@ -632,11 +665,13 @@ export async function executeLocalIntegrationJsonRequest( signal: signalLease.signal, }), }); - return await executeTransportRequest( + const result = await executeTransportRequest( request, options.transport ?? guardedTransport, signalLease.signal, + options, ); + return result; } finally { signalLease.release(); } diff --git a/src/integrations/local-integration-errors.ts b/src/integrations/local-integration-errors.ts index 8719fe87f3..bfa60aac0a 100644 --- a/src/integrations/local-integration-errors.ts +++ b/src/integrations/local-integration-errors.ts @@ -1,5 +1,8 @@ import { defineError } from "#veryfront/errors"; +const apply = Reflect.apply; +const stringCharCodeAt = String.prototype.charCodeAt; + export const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ slug: "local-integration-config-invalid", category: "CONFIG", @@ -48,6 +51,53 @@ export const LOCAL_INTEGRATION_RESPONSE_INVALID = defineError({ suggestion: "Check the provider response contract and retry", }); +export interface LocalIntegrationDiagnosticIdentity { + readonly connectorName: string; + readonly toolId: string; +} + +function safeIdentifier(value: unknown): string { + if (typeof value !== "string" || value.length === 0 || value.length > 200) return "unknown"; + for (let index = 0; index < value.length; index++) { + const code = apply(stringCharCodeAt, value, [index]) as number; + const allowed = code >= 48 && code <= 57 || code >= 65 && code <= 90 || + code >= 97 && code <= 122 || code === 45 || code === 46 || code === 47 || code === 95; + if (!allowed) return "unknown"; + } + return value; +} + +function providerDetail( + identity: LocalIntegrationDiagnosticIdentity, + outcome: string, + status?: number, +): string { + const connectorName = safeIdentifier(identity.connectorName); + const toolId = safeIdentifier(identity.toolId); + const statusDetail = status === undefined ? "" : ` with HTTP status ${status}`; + return `Local integration "${connectorName}" tool "${toolId}" ${outcome}${statusDetail}`; +} + +export function localIntegrationRequestFailed( + identity?: LocalIntegrationDiagnosticIdentity, + status?: number, +): never { + if (!identity) throw LOCAL_INTEGRATION_REQUEST_FAILED.create(); + throw LOCAL_INTEGRATION_REQUEST_FAILED.create({ + detail: providerDetail(identity, "request failed", status), + }); +} + +export function localIntegrationResponseInvalid( + identity?: LocalIntegrationDiagnosticIdentity, + status?: number, +): never { + if (!identity) throw LOCAL_INTEGRATION_RESPONSE_INVALID.create(); + throw LOCAL_INTEGRATION_RESPONSE_INVALID.create({ + detail: providerDetail(identity, "returned an invalid response", status), + }); +} + export function localIntegrationConfigurationError(detail: string): never { throw LOCAL_INTEGRATION_CONFIG_INVALID.create({ detail }); } diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index ae2a786689..348e8105f8 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -13,7 +13,8 @@ import { import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; import { loadRemoteToolsFromSource } from "#veryfront/tool"; import { executeConfiguredTool } from "#veryfront/agent/runtime/tool-helpers.ts"; -import { createLocalIntegrationToolSource } from "./index.ts"; +import { EXPERIMENTAL_INTEGRATIONS_ENV } from "./feature-flags.ts"; +import { createLocalIntegrationToolSource, getConnector } from "./index.ts"; import type { LocalIntegrationEndpointTransport } from "./local-endpoint-executor.ts"; import { _createLocalIntegrationToolSourceForTesting } from "./local-tool-source.ts"; @@ -78,7 +79,10 @@ async function assertConfigurationError( } describe("createLocalIntegrationToolSource", () => { - afterEach(() => _resetEnvironmentConfig()); + afterEach(() => { + _resetEnvironmentConfig(); + Deno.env.delete(EXPERIMENTAL_INTEGRATIONS_ENV); + }); it("lists only explicitly granted catalog tools with credential-free metadata", async () => { const source = createLocalIntegrationToolSource({ @@ -118,6 +122,18 @@ describe("createLocalIntegrationToolSource", () => { assertEquals(serialized.includes(TEST_CREDENTIAL), false); }); + it("removes credential variable names from model-facing catalog descriptions", async () => { + const source = createLocalIntegrationToolSource({ + tools: ["openai__get_costs"], + credentialProvider: testCredentialProvider, + }); + + const serialized = JSON.stringify(await source.listTools()); + + assertEquals(serialized.includes("OPENAI_API_KEY"), false); + assertEquals(serialized.includes(TEST_CREDENTIAL), false); + }); + it("snapshots its allowlist before caller mutation", async () => { const tools = ["vercel__list_projects"]; const source = createLocalIntegrationToolSource({ @@ -132,6 +148,39 @@ describe("createLocalIntegrationToolSource", () => { ]); }); + it("does not trust catalog metadata mutated through the public connector API", async () => { + _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); + Deno.env.set(EXPERIMENTAL_INTEGRATIONS_ENV, "anthropic"); + const connector = getConnector("anthropic"); + const publicTool = connector?.tools.find((tool) => tool.id === "anthropic__list_workspaces"); + assert(publicTool?.endpoint); + const originalUrl = publicTool.endpoint.url; + let requestUrl: string | undefined; + let apiKey: string | null = null; + + try { + publicTool.endpoint.url = "https://attacker.example/collect"; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["anthropic__list_workspaces"], + credentialProvider: () => TEST_CREDENTIAL, + }, + (request) => { + requestUrl = request.url.href; + apiKey = headerValue(request.init, "x-api-key"); + return Promise.resolve(Response.json({ data: [] })); + }, + ); + + await source.executeTool("anthropic__list_workspaces", {}); + } finally { + publicTool.endpoint.url = originalUrl; + } + + assertEquals(requestUrl, "https://api.anthropic.com/v1/organizations/workspaces?limit=20"); + assertEquals(apiKey, TEST_CREDENTIAL); + }); + it("retains admission semantics after project code mutates ambient primordials", async () => { _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); const restorers: Array<() => void> = []; @@ -169,6 +218,7 @@ describe("createLocalIntegrationToolSource", () => { appendRestorer(restorers, replaceProperty(String.prototype, "indexOf", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "lastIndexOf", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "replace", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "replaceAll", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "startsWith", poison)); appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 8c725b706c..d9af9d0cde 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -1,6 +1,7 @@ import { getEnvironmentConfig } from "#veryfront/config/environment-config.ts"; import type { JsonSchema } from "#veryfront/extensions/schema/index.ts"; import { getEnv } from "#veryfront/platform/compat/process/env.ts"; +import { snapshotBoundedJsonValue } from "#veryfront/schemas/json-value.ts"; import type { RemoteToolSource, ToolDefinition, @@ -38,6 +39,7 @@ const setAdd = Set.prototype.add; const setHas = Set.prototype.has; const stringIncludes = String.prototype.includes; const stringReplace = String.prototype.replace; +const stringReplaceAll = String.prototype.replaceAll; const stringStartsWith = String.prototype.startsWith; const URLConstructor = URL; const urlHash = Object.getOwnPropertyDescriptor(URL.prototype, "hash")?.get; @@ -64,13 +66,20 @@ type IntegrationEndpoint = NonNullable; interface AdmittedLocalIntegrationTool { readonly authPlan: LocalCredentialAuthPlan; - readonly connector: IntegrationConfig; + readonly connector: LocalCatalogConnector; readonly endpoint: IntegrationEndpoint; readonly endpointOrigin?: string; readonly tool: IntegrationToolMeta & { id: string }; readonly definition: ToolDefinition; } +type LocalCatalogConnector = Pick; + +interface LocalCatalogTool { + readonly connector: LocalCatalogConnector; + readonly tool: IntegrationToolMeta & { readonly id: string }; +} + function append(values: T[], value: T): void { objectDefineProperty(values, values.length, { configurable: true, @@ -88,6 +97,40 @@ function stringBoolean( return apply(operation, value, [search]); } +function removeCredentialNames(value: string, credentialNames: readonly string[]): string { + let sanitized = value; + for (let index = 0; index < credentialNames.length; index++) { + const name = credentialNames[index]!; + if (name.length === 0) { + configurationError("Local integration credential names must not be empty"); + } + sanitized = apply(stringReplaceAll, sanitized, [name, "configured credential"]); + } + return sanitized; +} + +function containsCredentialName(value: unknown, credentialNames: readonly string[]): boolean { + if (typeof value === "string") { + for (let index = 0; index < credentialNames.length; index++) { + if (stringBoolean(stringIncludes, value, credentialNames[index]!)) return true; + } + return false; + } + if (value === null || typeof value !== "object") return false; + + const entries = objectEntries(value); + for (let index = 0; index < entries.length; index++) { + const [key, entryValue] = entries[index]!; + if ( + containsCredentialName(key, credentialNames) || + containsCredentialName(entryValue, credentialNames) + ) { + return true; + } + } + return false; +} + function urlValue(getter: ((this: URL) => string) | undefined, url: URL): string { if (!getter) configurationError("URL parsing is unavailable in this runtime"); return apply(getter, url, []); @@ -157,39 +200,61 @@ function snapshotOptions(options: LocalIntegrationToolSourceOptions): { }; } -function declaredConnector(name: string): IntegrationConfig | undefined { - for (let index = 0; index < connectors.length; index++) { - const connector = connectors[index]; - if (connector?.name === name) return connector; +function catalogSnapshot(value: unknown, label: string): T { + const snapshot = snapshotBoundedJsonValue(value); + if (!snapshot.success) { + configurationError(`Local integration catalog ${label} is not data-only JSON`); } - return undefined; + return snapshot.value as T; } -function catalogTool( - connector: IntegrationConfig, - canonicalToolId: string, -): (IntegrationToolMeta & { id: string }) | undefined { - for (let index = 0; index < connector.tools.length; index++) { - const tool = connector.tools[index]; - const catalogId = tool?.id ?? tool?.name; - if ( - catalogId === canonicalToolId || - (catalogId !== undefined && `${connector.name}__${catalogId}` === canonicalToolId) - ) { +function captureLocalCatalog(): Map { + const captured = new MapConstructor(); + for (let connectorIndex = 0; connectorIndex < connectors.length; connectorIndex++) { + const connector = connectors[connectorIndex]; + if (!connector || typeof connector.name !== "string") continue; + const connectorSnapshot = freeze({ + name: connector.name, + auth: catalogSnapshot( + connector.auth, + `authentication for "${connector.name}"`, + ), + envVars: catalogSnapshot( + connector.envVars ?? [], + `environment variables for "${connector.name}"`, + ), + }); + + for (let toolIndex = 0; toolIndex < connector.tools.length; toolIndex++) { + const tool = connector.tools[toolIndex]; + const catalogId = tool?.id ?? tool?.name; + if (typeof catalogId !== "string") continue; + const canonicalToolId = stringBoolean(stringIncludes, catalogId, "__") + ? catalogId + : `${connector.name}__${catalogId}`; if (typeof tool?.name !== "string" || typeof tool.description !== "string") { configurationError(`Local integration tool "${canonicalToolId}" has invalid metadata`); } - return freeze({ + const toolSnapshot = catalogSnapshot({ ...tool, id: canonicalToolId, name: tool.name, description: tool.description, - }); + }, `tool "${canonicalToolId}"`); + apply(mapSet, captured, [ + canonicalToolId, + freeze({ + connector: connectorSnapshot, + tool: toolSnapshot, + }), + ]); } } - return undefined; + return captured; } +const localCatalog = captureLocalCatalog(); + function assertHttpsCatalogUrl(value: string, label: string): string { let parsed: URL; try { @@ -210,7 +275,7 @@ function assertHttpsCatalogUrl(value: string, label: string): string { } function assertSupportedAuth( - connector: IntegrationConfig, + connector: LocalCatalogConnector, endpoint: IntegrationEndpoint, ): void { const auth = connector.auth; @@ -253,7 +318,7 @@ function assertSupportedAuth( } function assertSupportedEndpoint( - connector: IntegrationConfig, + connector: LocalCatalogConnector, endpoint: IntegrationEndpoint, toolId: string, ): string | undefined { @@ -294,6 +359,7 @@ function inputPropertySchema( default?: unknown; exposeDefault?: boolean; }, + credentialNames: readonly string[], ): JsonSchema { if ( field.type !== "string" && field.type !== "number" && field.type !== "boolean" && @@ -303,7 +369,7 @@ function inputPropertySchema( } const schema: Record = { type: field.type === "string[]" ? "array" : field.type, - description: field.description, + description: removeCredentialNames(field.description, credentialNames), }; if (field.type === "string[]") schema.items = { type: "string" }; if (field.exposeDefault === true && field.default !== undefined) { @@ -315,6 +381,7 @@ function inputPropertySchema( function toolDefinition( tool: IntegrationToolMeta & { id: string }, endpoint: IntegrationEndpoint, + credentialNames: readonly string[], ): ToolDefinition { const properties: Record = {}; const required: string[] = []; @@ -322,7 +389,7 @@ function toolDefinition( const parameterEntries = objectEntries(endpoint.params ?? {}); for (let index = 0; index < parameterEntries.length; index++) { const [name, parameter] = parameterEntries[index]!; - properties[name] = inputPropertySchema(parameter); + properties[name] = inputPropertySchema(parameter, credentialNames); if (parameter.required) append(required, name); } const bodyEntries = objectEntries(endpoint.body ?? {}); @@ -331,13 +398,13 @@ function toolDefinition( if (properties[name]) { configurationError(`Local integration tool "${tool.id}" declares duplicate input "${name}"`); } - properties[name] = inputPropertySchema(field); + properties[name] = inputPropertySchema(field, credentialNames); if (field.required) append(required, name); } - return freeze({ + const definition = freeze({ name: tool.id, - description: tool.description, + description: removeCredentialNames(tool.description, credentialNames), parameters: freeze({ type: "object", properties: freeze(properties), @@ -345,6 +412,12 @@ function toolDefinition( additionalProperties: false, }) as JsonSchema, }); + if (containsCredentialName(definition, credentialNames)) { + configurationError( + `Local integration tool "${tool.id}" exposes a credential name outside descriptions`, + ); + } + return definition; } function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { @@ -353,14 +426,18 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { configurationError(`Local integration tool "${canonicalToolId}" must use a canonical ID`); } - const connector = declaredConnector(identity.integration); - if (!connector) { - configurationError(`Local integration tool "${canonicalToolId}" names an unknown connector`); - } - const tool = catalogTool(connector, canonicalToolId); - if (!tool) { + const catalogEntry = mapValue(localCatalog, canonicalToolId); + if (!catalogEntry) { + let knownConnector = false; + for (let index = 0; index < connectors.length; index++) { + if (connectors[index]?.name === identity.integration) knownConnector = true; + } + if (!knownConnector) { + configurationError(`Local integration tool "${canonicalToolId}" names an unknown connector`); + } configurationError(`Local integration tool "${canonicalToolId}" is unknown`); } + const { connector, tool } = catalogEntry; if (!tool.endpoint) { configurationError(`Local integration tool "${canonicalToolId}" has no executable endpoint`); } @@ -371,13 +448,18 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { canonicalToolId, ); assertSupportedAuth(connector, tool.endpoint); + const authPlan = createLocalCredentialAuthPlan(connector); return freeze({ - authPlan: createLocalCredentialAuthPlan(connector), + authPlan, connector, endpoint: tool.endpoint, endpointOrigin, tool, - definition: toolDefinition(tool, tool.endpoint), + definition: toolDefinition( + tool, + tool.endpoint, + authPlan.requiredEnvironmentVariables, + ), }); } @@ -436,6 +518,7 @@ function createLocalIntegrationToolSourceInternal( } const auth = await mintLocalCredentialAuth( await resolveLocalCredentialAuth(tool.authPlan, credentialProvider), + toolName, context?.abortSignal, transport, ); @@ -458,6 +541,8 @@ function createLocalIntegrationToolSourceInternal( configurationError(`Local integration tool "${toolName}" has no admitted origin`); } return await executeLocalIntegrationEndpoint({ + connectorName: tool.connector.name, + toolId: toolName, endpoint, args, authHeaders: auth.headers, From 3d2112f28d9254a628ead59baf8a8ec46e8c1427 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 06:24:51 +0200 Subject: [PATCH 10/25] Reject malformed local integration calls before credentials move Validate catalog credential metadata and tool arguments before credential resolution, treat successful no-content responses as null, register the local boundary errors centrally, and document the direct local execution boundary. Constraint: No provider request or credential lookup may occur for an invalid tool invocation Rejected: Rely only on endpoint execution validation | OAuth minting happens before endpoint execution Confidence: high Scope-risk: moderate Directive: Keep argument admission before all credential work and preserve 204 as a successful empty result Tested: 15-suite integration and tool matrix (38 tests, 243 steps); error registry (119 slugs); docs validation (1,385 links); deno check, lint, fmt, anti-slop, diff checks Not-tested: Live provider credentials and third-party endpoints --- docs/api-reference/veryfront/errors.md | 264 +++++++++--------- docs/api-reference/veryfront/integrations.md | 6 +- docs/architecture/19-integration-runtime.md | 37 ++- docs/architecture/20-support-matrix.md | 1 + docs/guides/errors.md | 42 +++ docs/guides/integrations.md | 4 +- src/README.md | 5 +- src/errors/error-registry.test.ts | 28 +- src/errors/error-registry/boundary.ts | 9 + src/errors/error-registry/config.ts | 18 ++ src/errors/error-registry/runtime.ts | 27 ++ src/errors/index.ts | 6 + src/integrations/limits.ts | 3 + .../local-credential-auth.test.ts | 38 +++ src/integrations/local-credential-auth.ts | 74 ++++- .../local-endpoint-executor.test.ts | 15 + src/integrations/local-endpoint-executor.ts | 36 ++- src/integrations/local-integration-errors.ts | 63 +---- src/integrations/local-tool-source.test.ts | 28 ++ src/integrations/local-tool-source.ts | 4 +- tests/docs/guide-code-examples.test.ts | 2 +- 21 files changed, 493 insertions(+), 217 deletions(-) diff --git a/docs/api-reference/veryfront/errors.md b/docs/api-reference/veryfront/errors.md index 86a7d64b05..024da34343 100644 --- a/docs/api-reference/veryfront/errors.md +++ b/docs/api-reference/veryfront/errors.md @@ -37,135 +37,141 @@ throw INVALID_WIDGET.create({ detail: "The widget id is malformed." }); ### Components -| Name | Description | Source | -| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | -| `AGENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L3) | -| `AGENT_INTENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L27) | -| `AGENT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L11) | -| `AGENT_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L19) | -| `API_CLIENT_ERROR` | API client request/response errors (replaces VeryfrontAPIError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L93) | -| `API_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L52) | -| `API_ROUTE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L43) | -| `ASSET_OPTIMIZATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L43) | -| `AUTHENTICATION_REQUIRED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L11) | -| `BRANCH_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L117) | -| `BUILD_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/build-errors.ts#L4) | -| `BUILD_FAILED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L3) | -| `BUNDLE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L11) | -| `CACHE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L20) | -| `CACHE_INVARIANT_VIOLATION` | Cache path invariant violations (replaces CacheInvariantError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L111) | -| `CACHE_PATH_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L76) | -| `CIRCUIT_BREAKER_OPEN` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L68) | -| `CIRCULAR_DEPENDENCY` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L19) | -| `CLIENT_BOUNDARY_VIOLATION` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L3) | -| `CLIENT_ONLY_IN_SERVER` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L19) | -| `COMPILATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L67) | -| `COMPONENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L28) | -| `CONFIG_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/config-errors.ts#L4) | -| `CONFIG_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L12) | -| `CONFIG_NOT_DEPLOYABLE` | The project's configuration file uses a construct Veryfront Cloud's configuration evaluator can never accept, so the release would answer 500 to every request. Raised before a release is created; the detail names the file, the change that makes the project deployable, and the line when the evaluator located the construct it refused. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L132) | -| `CONFIG_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L3) | -| `CONFIG_PARSE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L20) | -| `CONFIG_TYPE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L37) | -| `CONFIG_VALIDATION_ERROR` | Schema-level config validation (e.g. Zod schema mismatch at runtime) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L29) | -| `CONFIG_VALIDATION_FAILED` | Config file validation failures (replaces ConfigValidationError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L62) | -| `CORS_CONFIG_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L53) | -| `COST_LIMIT_EXCEEDED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L43) | -| `DEPENDENCY_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L35) | -| `DEPLOYMENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L3) | -| `DEPLOYMENT_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/deployment-errors.ts#L4) | -| `DEPLOYMENT_VERIFICATION_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L68) | -| `DEV_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/dev-errors.ts#L4) | -| `DEV_SERVER_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L11) | -| `DURABLE_RUN_EVENT_PERSISTENCE_FAILED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L59) | -| `DYNAMIC_ROUTE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L27) | -| `ENV_VAR_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L19) | -| `ENVIRONMENT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L35) | -| `ENVIRONMENT_NOT_ROUTABLE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L43) | -| `ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/index.ts#L31) | -| `ERROR_OVERLAY_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L27) | -| `ERROR_REGISTRY` | Central registry mapping every error slug to its definition. Assembled from the per-category registry fragments. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry.ts#L39) | -| `ERROR_SOLUTIONS` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/user-friendly/error-catalog.ts#L6) | -| `FALLBACK_EXHAUSTED` | Both primary and fallback operations failed (replaces FallbackExecutionError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L129) | -| `FAST_REFRESH_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L19) | -| `FILE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L27) | -| `FILE_WATCH_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L28) | -| `GENERAL_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/general-errors.ts#L4) | -| `HMR_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L3) | -| `HYDRATION_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L3) | -| `IMPORT_MAP_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L45) | -| `IMPORT_RESOLUTION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L11) | -| `INITIALIZATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L60) | -| `INPUT_VALIDATION_FAILED` | HTTP request input validation failures (replaces ValidationError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L86) | -| `INVALID_ARGUMENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L43) | -| `INVALID_IMPORT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L27) | -| `INVALID_ROUTE_FILE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L11) | -| `INVALID_USE_CLIENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L27) | -| `INVALID_USE_SERVER` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L35) | -| `LAYOUT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L36) | -| `LOCKFILE_FORMAT_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L51) | -| `LOCKFILE_READ_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L59) | -| `MARKDOWN_COMPILE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L35) | -| `MDX_COMPILE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L27) | -| `MIDDLEWARE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L60) | -| `MODULE_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/module-errors.ts#L4) | -| `MODULE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L3) | -| `NESTED_CWD_SCOPE` | A scope that owns the process working directory was opened inside another one. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L103) | -| `NETWORK_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L84) | -| `NOT_SUPPORTED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L68) | -| `ORCHESTRATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L35) | -| `PAGE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L44) | -| `PERMISSION_DENIED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L19) | -| `PLATFORM_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L11) | -| `PORT_IN_USE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L3) | -| `PREVIEW_HOSTNAME_TOO_LONG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L109) | -| `PROBLEM_JSON_CONTENT_TYPE` | Content-Type header for RFC 9457 responses | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/http-error.ts#L32) | -| `PRODUCTION_BUILD_REQUIRED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L27) | -| `PROJECT_EXECUTION_UNAVAILABLE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L52) | -| `PROJECT_SOURCE_EMPTY` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L94) | -| `PUSH_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L84) | -| `PUSH_RECEIPT_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L76) | -| `RAG_STORE_CORRUPT` | Persisted RAG index is malformed or failed structural validation. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L138) | -| `RAG_STORE_UNAVAILABLE` | A persisted RAG index operation could not be completed safely. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L147) | -| `REDIRECT_DESTINATION_NOT_ALLOWED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L19) | -| `RELEASE_BUILD_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L60) | -| `RELEASE_MISSING_VERSION` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L52) | -| `RELEASE_NOT_FOUND` | Production domain resolved but no active release found | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L120) | -| `RENDER_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L11) | -| `REQUEST_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L36) | -| `RESOURCE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L35) | -| `ROUTE_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L3) | -| `ROUTE_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/route-errors.ts#L4) | -| `ROUTE_HANDLER_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L19) | -| `ROUTE_PARAMS_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L35) | -| `RSC_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/rsc-errors.ts#L4) | -| `RSC_PAYLOAD_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L43) | -| `RUNTIME_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/runtime-errors.ts#L4) | -| `SCHEDULE_CONFIG_INVALID` | Schedule definition validation failures (required fields, cron, concurrencyPolicy, target) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L80) | -| `SECURITY_VIOLATION` | Path traversal / secure-fs violations (replaces SecurityError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L77) | -| `SEMAPHORE_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L60) | -| `SERVER_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/server-errors.ts#L4) | -| `SERVER_ONLY_IN_CLIENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L11) | -| `SERVER_START_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L12) | -| `SERVICE_OVERLOADED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L44) | -| `SOURCE_DIGEST_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L101) | -| `SOURCE_MAP_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L35) | -| `SOURCEMAP_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L59) | -| `SSG_GENERATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L51) | -| `SSR_OUTPUT_LIMIT_EXCEEDED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L51) | -| `SYNC_STATE_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L93) | -| `TEMPLATE_NOT_FOUND` | `veryfront init --template ` (and `npm create veryfront -- --template`) was given a name that is not in the starter catalog. The detail carries the list of valid names so a wrong guess is self-correcting. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L104) | -| `TIMEOUT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L52) | -| `TOKEN_STORAGE_ERROR` | Token storage adapter failures (replaces TokenStorageError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L102) | -| `TOOL_ID_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L51) | -| `TRIGGER_CONFIG_INVALID` | Trigger ID format and input serialization validation failures | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L90) | -| `TRIGGER_EXECUTION_FAILED` | Trigger target task or workflow failed during local run | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L78) | -| `TRIGGER_NOT_SUPPORTED` | Trigger target type is not supported in the current runtime context | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L87) | -| `TRIGGER_TARGET_NOT_FOUND` | Trigger target (task or workflow) not found during local run | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L69) | -| `TYPESCRIPT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L19) | -| `UNKNOWN_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L3) | -| `VERSION_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L43) | -| `WEBHOOK_CONFIG_INVALID` | Webhook definition validation failures (required fields, target, eventFilter) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L71) | +| Name | Description | Source | +| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | +| `AGENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L3) | +| `AGENT_INTENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L27) | +| `AGENT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L11) | +| `AGENT_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L19) | +| `API_CLIENT_ERROR` | API client request/response errors (replaces VeryfrontAPIError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L93) | +| `API_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L52) | +| `API_ROUTE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L43) | +| `ASSET_OPTIMIZATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L43) | +| `AUTHENTICATION_REQUIRED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L11) | +| `BRANCH_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L117) | +| `BUILD_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/build-errors.ts#L4) | +| `BUILD_FAILED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L3) | +| `BUNDLE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L11) | +| `CACHE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L20) | +| `CACHE_INVARIANT_VIOLATION` | Cache path invariant violations (replaces CacheInvariantError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L111) | +| `CACHE_PATH_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L76) | +| `CIRCUIT_BREAKER_OPEN` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L68) | +| `CIRCULAR_DEPENDENCY` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L19) | +| `CLIENT_BOUNDARY_VIOLATION` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L3) | +| `CLIENT_ONLY_IN_SERVER` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L19) | +| `COMPILATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L67) | +| `COMPONENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L28) | +| `CONFIG_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/config-errors.ts#L4) | +| `CONFIG_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L12) | +| `CONFIG_NOT_DEPLOYABLE` | The project's configuration file uses a construct Veryfront Cloud's configuration evaluator can never accept, so the release would answer 500 to every request. Raised before a release is created; the detail names the file, the change that makes the project deployable, and the line when the evaluator located the construct it refused. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L132) | +| `CONFIG_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L3) | +| `CONFIG_PARSE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L20) | +| `CONFIG_TYPE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L37) | +| `CONFIG_VALIDATION_ERROR` | Schema-level config validation (e.g. Zod schema mismatch at runtime) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L29) | +| `CONFIG_VALIDATION_FAILED` | Config file validation failures (replaces ConfigValidationError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L62) | +| `CORS_CONFIG_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L53) | +| `COST_LIMIT_EXCEEDED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L43) | +| `DEPENDENCY_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L35) | +| `DEPLOYMENT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L3) | +| `DEPLOYMENT_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/deployment-errors.ts#L4) | +| `DEPLOYMENT_VERIFICATION_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L68) | +| `DEV_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/dev-errors.ts#L4) | +| `DEV_SERVER_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L11) | +| `DURABLE_RUN_EVENT_PERSISTENCE_FAILED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L59) | +| `DYNAMIC_ROUTE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L27) | +| `ENV_VAR_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L19) | +| `ENVIRONMENT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L35) | +| `ENVIRONMENT_NOT_ROUTABLE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L43) | +| `ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/index.ts#L31) | +| `ERROR_OVERLAY_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L27) | +| `ERROR_REGISTRY` | Central registry mapping every error slug to its definition. Assembled from the per-category registry fragments. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry.ts#L39) | +| `ERROR_SOLUTIONS` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/user-friendly/error-catalog.ts#L6) | +| `FALLBACK_EXHAUSTED` | Both primary and fallback operations failed (replaces FallbackExecutionError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L129) | +| `FAST_REFRESH_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L19) | +| `FILE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L27) | +| `FILE_WATCH_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L28) | +| `GENERAL_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/general-errors.ts#L4) | +| `HMR_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L3) | +| `HYDRATION_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L3) | +| `IMPORT_MAP_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L45) | +| `IMPORT_RESOLUTION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L11) | +| `INITIALIZATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L60) | +| `INPUT_VALIDATION_FAILED` | HTTP request input validation failures (replaces ValidationError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L86) | +| `INVALID_ARGUMENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L43) | +| `INVALID_IMPORT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L27) | +| `INVALID_ROUTE_FILE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L11) | +| `INVALID_USE_CLIENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L27) | +| `INVALID_USE_SERVER` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L35) | +| `LAYOUT_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L36) | +| `LOCAL_INTEGRATION_CONFIG_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L70) | +| `LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L68) | +| `LOCAL_INTEGRATION_CREDENTIALS_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L78) | +| `LOCAL_INTEGRATION_REQUEST_FAILED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L76) | +| `LOCAL_INTEGRATION_REQUEST_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L59) | +| `LOCAL_INTEGRATION_RESPONSE_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L84) | +| `LOCKFILE_FORMAT_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L51) | +| `LOCKFILE_READ_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L59) | +| `MARKDOWN_COMPILE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L35) | +| `MDX_COMPILE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L27) | +| `MIDDLEWARE_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L60) | +| `MODULE_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/module-errors.ts#L4) | +| `MODULE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L3) | +| `NESTED_CWD_SCOPE` | A scope that owns the process working directory was opened inside another one. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L103) | +| `NETWORK_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L84) | +| `NOT_SUPPORTED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L68) | +| `ORCHESTRATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L35) | +| `PAGE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L44) | +| `PERMISSION_DENIED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L19) | +| `PLATFORM_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L11) | +| `PORT_IN_USE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L3) | +| `PREVIEW_HOSTNAME_TOO_LONG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L109) | +| `PROBLEM_JSON_CONTENT_TYPE` | Content-Type header for RFC 9457 responses | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/http-error.ts#L32) | +| `PRODUCTION_BUILD_REQUIRED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L27) | +| `PROJECT_EXECUTION_UNAVAILABLE` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L52) | +| `PROJECT_SOURCE_EMPTY` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L94) | +| `PUSH_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L84) | +| `PUSH_RECEIPT_MISSING` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L76) | +| `RAG_STORE_CORRUPT` | Persisted RAG index is malformed or failed structural validation. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L138) | +| `RAG_STORE_UNAVAILABLE` | A persisted RAG index operation could not be completed safely. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L147) | +| `REDIRECT_DESTINATION_NOT_ALLOWED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L19) | +| `RELEASE_BUILD_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L60) | +| `RELEASE_MISSING_VERSION` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L52) | +| `RELEASE_NOT_FOUND` | Production domain resolved but no active release found | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L120) | +| `RENDER_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L11) | +| `REQUEST_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L36) | +| `RESOURCE_NOT_FOUND` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L35) | +| `ROUTE_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L3) | +| `ROUTE_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/route-errors.ts#L4) | +| `ROUTE_HANDLER_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L19) | +| `ROUTE_PARAMS_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/route.ts#L35) | +| `RSC_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/rsc-errors.ts#L4) | +| `RSC_PAYLOAD_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L43) | +| `RUNTIME_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/runtime-errors.ts#L4) | +| `SCHEDULE_CONFIG_INVALID` | Schedule definition validation failures (required fields, cron, concurrencyPolicy, target) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L96) | +| `SECURITY_VIOLATION` | Path traversal / secure-fs violations (replaces SecurityError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L77) | +| `SEMAPHORE_TIMEOUT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L60) | +| `SERVER_ERROR_CATALOG` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/catalog/server-errors.ts#L4) | +| `SERVER_ONLY_IN_CLIENT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L11) | +| `SERVER_START_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L12) | +| `SERVICE_OVERLOADED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L44) | +| `SOURCE_DIGEST_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L101) | +| `SOURCE_MAP_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/dev.ts#L35) | +| `SOURCEMAP_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L59) | +| `SSG_GENERATION_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L51) | +| `SSR_OUTPUT_LIMIT_EXCEEDED` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/boundary.ts#L51) | +| `SYNC_STATE_INVALID` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/deploy.ts#L93) | +| `TEMPLATE_NOT_FOUND` | `veryfront init --template ` (and `npm create veryfront -- --template`) was given a name that is not in the starter catalog. The detail carries the list of valid names so a wrong guess is self-correcting. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L120) | +| `TIMEOUT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L52) | +| `TOKEN_STORAGE_ERROR` | Token storage adapter failures (replaces TokenStorageError) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/server.ts#L102) | +| `TOOL_ID_CONFLICT` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/agent.ts#L51) | +| `TRIGGER_CONFIG_INVALID` | Trigger ID format and input serialization validation failures | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L106) | +| `TRIGGER_EXECUTION_FAILED` | Trigger target task or workflow failed during local run | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L102) | +| `TRIGGER_NOT_SUPPORTED` | Trigger target type is not supported in the current runtime context | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L111) | +| `TRIGGER_TARGET_NOT_FOUND` | Trigger target (task or workflow) not found during local run | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/runtime.ts#L93) | +| `TYPESCRIPT_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/build.ts#L19) | +| `UNKNOWN_ERROR` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/general.ts#L3) | +| `VERSION_MISMATCH` | | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/module.ts#L43) | +| `WEBHOOK_CONFIG_INVALID` | Webhook definition validation failures (required fields, target, eventFilter) | [source](https://github.com/veryfront/veryfront-code/blob/main/src/errors/error-registry/config.ts#L87) | ### Functions diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index a685d42146..fbbb63e1b1 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -54,7 +54,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L558) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L560) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | | `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | @@ -76,8 +76,8 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | | `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | | `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L53) | -| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L58) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L54) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L59) | | `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | | `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | | `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | diff --git a/docs/architecture/19-integration-runtime.md b/docs/architecture/19-integration-runtime.md index 135b374ef3..93962b889b 100644 --- a/docs/architecture/19-integration-runtime.md +++ b/docs/architecture/19-integration-runtime.md @@ -1,13 +1,14 @@ # Integration runtime This page describes the connector catalog, integration metadata schemas, and -remote integration tool loading and execution. It does not cover OAuth route -handlers or local tool definitions. +the remote and local integration tool execution paths. It does not cover OAuth +route handlers or project-authored tools. ## Responsibility -Integration code exposes connector metadata, icons, and per-request remote tools -fetched from the configured API layer. +Integration code exposes connector metadata, icons, per-request remote tools +fetched from the configured API layer, and exact-grant local tools backed by +project-owned credentials. Primary source areas: @@ -16,6 +17,8 @@ Primary source areas: - [`src/integrations/schema.ts`](../../src/integrations/schema.ts) - [`src/integrations/_data.ts`](../../src/integrations/_data.ts) - [`src/integrations/remote-tools.ts`](../../src/integrations/remote-tools.ts) +- [`src/integrations/local-tool-source.ts`](../../src/integrations/local-tool-source.ts) +- [`src/integrations/local-endpoint-executor.ts`](../../src/integrations/local-endpoint-executor.ts) - [`src/integrations/types.ts`](../../src/integrations/types.ts) ## Runtime flow @@ -36,6 +39,12 @@ flowchart TD readiness --> execute execute --> api[Integrations tools API] api --> result[Structured tool result or sanitized error] + + localGrant[Exact local tool grant] --> localTool[Build local tool definitions] + localTool --> localCall[Model requests local integration tool] + localCall --> credential[Resolve named project credential] + credential --> provider[Call supported provider REST endpoint] + provider --> localResult[Structured tool result or sanitized error] ``` 1. Connector metadata defines supported providers, auth requirements, tools, @@ -51,20 +60,28 @@ flowchart TD 7. Remote tool helpers resolve request-scoped or environment API credentials. 8. Tool definitions are fetched per request so source-declared integration requests remain project-scoped. -9. Tool execution is delegated to the configured API layer and normalized for - the agent runtime. +9. Remote tool execution is delegated to the configured API layer and normalized + for the agent runtime. +10. A local source can instead grant exact catalog tool IDs, resolve catalog- + named credentials immediately before each call, and execute supported HTTPS + REST endpoints without a Veryfront account or project token. ## Boundaries -- Integration runtime owns connector metadata and remote tool bridge behavior. +- Integration runtime owns connector metadata, the remote tool bridge, and the + bounded local endpoint executor. - Agent source owns the agent's integration tool declaration. - Exact-source `veryfront.config.ts` owns an optional monotonic allowlist. Its absence is unrestricted; it never enables an integration or grants credentials. - The control plane owns optional project policy and connection inventory. - OAuth runtime owns provider redirects, callbacks, and token storage. -- Local project tools belong in [agent runtime](./05-agent-runtime.md) and the +- Project-authored tools belong in [agent runtime](./05-agent-runtime.md) and the public [Tools](../guides/tools.md) guide. -- The backing API owns actual third-party API calls and provider token access. +- The backing API owns provider token access and third-party API calls for remote + integration tools. +- A local integration source owns only its exact tool grant. The runtime resolves + catalog-named credentials from the project boundary and makes supported direct + provider calls without exposing credentials to tool arguments or the model. Effective integration capability is the intersection of agent selection, connector catalog, source configuration, and control-plane policy. No policy @@ -82,6 +99,8 @@ child; handler-local tool-list rewriting is not an authorization boundary. metadata. - Add remote-tool tests when changing request-scoped token resolution, tool listing, call payloads, or result normalization. +- Add local-source and endpoint-executor tests when changing exact-grant + admission, credential resolution, request construction, or response handling. - Keep per-project tool visibility scoped to the active request or environment token. - Keep config caches qualified by the exact branch, release, or environment; diff --git a/docs/architecture/20-support-matrix.md b/docs/architecture/20-support-matrix.md index 72fef25b01..9f8a79442b 100644 --- a/docs/architecture/20-support-matrix.md +++ b/docs/architecture/20-support-matrix.md @@ -47,6 +47,7 @@ on a backing API or cloud bootstrap. | Runs client | Requires backing API/service layer | Exposed as SDK/API surface for task, workflow, and agent execution. | | Sandbox | Requires backing API/service layer | Depends on authenticated sandbox session APIs. | | Remote integration tools | Requires backing API/service layer | Tool definitions and execution are fetched per request from the configured API layer. | +| Local catalog integration tools | Open-core with provider credentials/runtime setup | Exact-grant local sources execute supported HTTPS REST endpoints directly. | | Control-plane agent routing | Requires Veryfront Cloud bootstrap | EdDSA-signed request validation for hosted agent orchestration. | ## Extension contract matrix diff --git a/docs/guides/errors.md b/docs/guides/errors.md index 07c6fbfe1c..5dc4663b23 100644 --- a/docs/guides/errors.md +++ b/docs/guides/errors.md @@ -74,6 +74,20 @@ Configuration validation failed. - **HTTP status:** 400 - **What to do:** Check configuration values against requirements +### local-integration-config-invalid + +Invalid local integration configuration. + +- **HTTP status:** 400 +- **What to do:** Use exact catalog tool IDs and supported local credential and endpoint contracts + +### local-integration-credentials-missing + +Local integration credentials are missing. + +- **HTTP status:** 400 +- **What to do:** Set the named environment variables or configure a credential provider + ### webhook-config-invalid Invalid webhook configuration. @@ -230,6 +244,27 @@ Middleware execution error. - **HTTP status:** 500 - **What to do:** Check middleware function for errors +### local-integration-credential-unavailable + +Local integration credential is unavailable. + +- **HTTP status:** 503 +- **What to do:** Check the local credential provider and retry + +### local-integration-request-failed + +Local integration request failed. + +- **HTTP status:** 502 +- **What to do:** Check the provider status and local integration configuration, then retry + +### local-integration-response-invalid + +Local integration response is invalid. + +- **HTTP status:** 502 +- **What to do:** Check the provider response contract and retry + ### trigger-target-not-found Trigger target not found. @@ -540,6 +575,13 @@ SSR output limit exceeded. - **HTTP status:** 500 - **What to do:** Reduce the rendered HTML size or split the response into smaller pages +### local-integration-request-invalid + +Local integration request is invalid. + +- **HTTP status:** 400 +- **What to do:** Pass only the documented tool arguments with their declared JSON types + ## Development tooling Raised by the local development workflow. diff --git a/docs/guides/integrations.md b/docs/guides/integrations.md index 9682b01199..8ddc5ebd9a 100644 --- a/docs/guides/integrations.md +++ b/docs/guides/integrations.md @@ -21,8 +21,8 @@ inventory records credential readiness independently of all three. ## Run account-free local integration tools -Use the catalog-backed local source when a local or self-hosted project needs to -call supported REST integrations without a Veryfront account or project token: +Use the catalog-backed local source to call supported REST integrations from a +local or self-hosted project without a Veryfront account or project token: ```ts import { agent } from "veryfront/agent"; diff --git a/src/README.md b/src/README.md index 3001675501..8361a46ef4 100644 --- a/src/README.md +++ b/src/README.md @@ -72,7 +72,7 @@ | **`task/`** | `#veryfront/task` | Task definitions and runner | | **`sandbox/`** | `veryfront/sandbox` | Ephemeral compute environments | | **`channels/`** | `#veryfront/channels` | Control-plane agent routing | -| **`integrations/`** | `veryfront/integrations` | Third-party connector metadata and remote tools | +| **`integrations/`** | `veryfront/integrations` | Connector metadata, local tools, and remote tools | | **`internal-agents/`** | - | Hosted agent runtime (AG-UI, sessions, auth) | | **`schemas/`** | `#veryfront/schemas` | Shared Zod validation schemas and `defineSchema` | | **`registry/`** | - | Project-scoped multi-tenant registry manager | @@ -638,7 +638,8 @@ See [`transforms/import-rewriter/README.md`](./transforms/import-rewriter/README **Exports**: `veryfront/integrations` - Integration metadata and SVG icons for all connectors -- Remote tool definitions for third-party services +- Exact-grant local tools for supported REST endpoints and project credentials +- Remote tool definitions and execution through the configured API layer - OAuth configuration schemas #### `internal-agents/` - Hosted Agent Runtime diff --git a/src/errors/error-registry.test.ts b/src/errors/error-registry.test.ts index 44b6540274..035595f9d3 100644 --- a/src/errors/error-registry.test.ts +++ b/src/errors/error-registry.test.ts @@ -29,9 +29,25 @@ describe("error-registry", () => { assertEquals(slugs.length, uniqueSlugs.size, "Duplicate slugs detected"); }); - it("should have 113 registered errors", () => { + it("should have 119 registered errors", () => { const slugs = getAllSlugs(); - assertEquals(slugs.length, 113); + assertEquals(slugs.length, 119); + }); + + it("registers every local integration boundary error", () => { + const slugs = new Set(getAllSlugs()); + for ( + const slug of [ + "local-integration-config-invalid", + "local-integration-credentials-missing", + "local-integration-credential-unavailable", + "local-integration-request-invalid", + "local-integration-request-failed", + "local-integration-response-invalid", + ] as const + ) { + assertEquals(slugs.has(slug), true, `Missing registered error slug "${slug}"`); + } }); }); @@ -172,7 +188,7 @@ describe("error-registry", () => { describe("getErrorsByCategory", () => { it("should return CONFIG errors", () => { const errors = getErrorsByCategory("CONFIG"); - assertEquals(errors.length, 12); + assertEquals(errors.length, 14); for (const error of errors) { assertEquals(error.category, "CONFIG"); } @@ -321,13 +337,13 @@ describe("error-registry", () => { describe("error categories coverage", () => { const expectedCategoryCounts: Record = { - CONFIG: 12, + CONFIG: 14, BUILD: 9, - RUNTIME: 11, + RUNTIME: 14, ROUTE: 6, MODULE: 8, SERVER: 18, - BOUNDARY: 7, + BOUNDARY: 8, DEV: 5, DEPLOY: 16, AGENT: 8, diff --git a/src/errors/error-registry/boundary.ts b/src/errors/error-registry/boundary.ts index f1cc0feff2..9816e50272 100644 --- a/src/errors/error-registry/boundary.ts +++ b/src/errors/error-registry/boundary.ts @@ -56,6 +56,14 @@ export const SSR_OUTPUT_LIMIT_EXCEEDED = defineError({ suggestion: "Reduce the rendered HTML size or split the response into smaller pages", }); +export const LOCAL_INTEGRATION_REQUEST_INVALID = defineError({ + slug: "local-integration-request-invalid", + category: "BOUNDARY", + status: 400, + title: "Local integration request is invalid", + suggestion: "Pass only the documented tool arguments with their declared JSON types", +}); + /** Registry fragment for BOUNDARY errors (slug → definition). */ export const BOUNDARY_REGISTRY = { "client-boundary-violation": CLIENT_BOUNDARY_VIOLATION, @@ -65,4 +73,5 @@ export const BOUNDARY_REGISTRY = { "invalid-use-server": INVALID_USE_SERVER, "rsc-payload-error": RSC_PAYLOAD_ERROR, "ssr-output-limit-exceeded": SSR_OUTPUT_LIMIT_EXCEEDED, + "local-integration-request-invalid": LOCAL_INTEGRATION_REQUEST_INVALID, } as const; diff --git a/src/errors/error-registry/config.ts b/src/errors/error-registry/config.ts index d6859744a2..c9fea6c352 100644 --- a/src/errors/error-registry/config.ts +++ b/src/errors/error-registry/config.ts @@ -67,6 +67,22 @@ export const CONFIG_VALIDATION_FAILED = defineError({ suggestion: "Check configuration values against requirements", }); +export const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ + slug: "local-integration-config-invalid", + category: "CONFIG", + status: 400, + title: "Invalid local integration configuration", + suggestion: "Use exact catalog tool IDs and supported local credential and endpoint contracts", +}); + +export const LOCAL_INTEGRATION_CREDENTIALS_MISSING = defineError({ + slug: "local-integration-credentials-missing", + category: "CONFIG", + status: 400, + title: "Local integration credentials are missing", + suggestion: "Set the named environment variables or configure a credential provider", +}); + /** Webhook definition validation failures (required fields, target, eventFilter) */ export const WEBHOOK_CONFIG_INVALID = defineError({ slug: "webhook-config-invalid", @@ -120,6 +136,8 @@ export const CONFIG_REGISTRY = { "import-map-invalid": IMPORT_MAP_INVALID, "cors-config-invalid": CORS_CONFIG_INVALID, "config-validation-failed": CONFIG_VALIDATION_FAILED, + "local-integration-config-invalid": LOCAL_INTEGRATION_CONFIG_INVALID, + "local-integration-credentials-missing": LOCAL_INTEGRATION_CREDENTIALS_MISSING, "webhook-config-invalid": WEBHOOK_CONFIG_INVALID, "schedule-config-invalid": SCHEDULE_CONFIG_INVALID, "trigger-config-invalid": TRIGGER_CONFIG_INVALID, diff --git a/src/errors/error-registry/runtime.ts b/src/errors/error-registry/runtime.ts index 1e6473c487..28bcf25373 100644 --- a/src/errors/error-registry/runtime.ts +++ b/src/errors/error-registry/runtime.ts @@ -65,6 +65,30 @@ export const MIDDLEWARE_ERROR = defineError({ suggestion: "Check middleware function for errors", }); +export const LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE = defineError({ + slug: "local-integration-credential-unavailable", + category: "RUNTIME", + status: 503, + title: "Local integration credential is unavailable", + suggestion: "Check the local credential provider and retry", +}); + +export const LOCAL_INTEGRATION_REQUEST_FAILED = defineError({ + slug: "local-integration-request-failed", + category: "RUNTIME", + status: 502, + title: "Local integration request failed", + suggestion: "Check the provider status and local integration configuration, then retry", +}); + +export const LOCAL_INTEGRATION_RESPONSE_INVALID = defineError({ + slug: "local-integration-response-invalid", + category: "RUNTIME", + status: 502, + title: "Local integration response is invalid", + suggestion: "Check the provider response contract and retry", +}); + /** Trigger target (task or workflow) not found during local run */ export const TRIGGER_TARGET_NOT_FOUND = defineError({ slug: "trigger-target-not-found", @@ -103,6 +127,9 @@ export const RUNTIME_REGISTRY = { "page-not-found": PAGE_NOT_FOUND, "api-error": API_ERROR, "middleware-error": MIDDLEWARE_ERROR, + "local-integration-credential-unavailable": LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, + "local-integration-request-failed": LOCAL_INTEGRATION_REQUEST_FAILED, + "local-integration-response-invalid": LOCAL_INTEGRATION_RESPONSE_INVALID, "trigger-target-not-found": TRIGGER_TARGET_NOT_FOUND, "trigger-execution-failed": TRIGGER_EXECUTION_FAILED, "trigger-not-supported": TRIGGER_NOT_SUPPORTED, diff --git a/src/errors/index.ts b/src/errors/index.ts index 4bdafcbefd..c4f3b3522c 100644 --- a/src/errors/index.ts +++ b/src/errors/index.ts @@ -98,6 +98,12 @@ export { INVALID_USE_CLIENT, INVALID_USE_SERVER, LAYOUT_NOT_FOUND, + LOCAL_INTEGRATION_CONFIG_INVALID, + LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, + LOCAL_INTEGRATION_CREDENTIALS_MISSING, + LOCAL_INTEGRATION_REQUEST_FAILED, + LOCAL_INTEGRATION_REQUEST_INVALID, + LOCAL_INTEGRATION_RESPONSE_INVALID, LOCKFILE_FORMAT_MISMATCH, LOCKFILE_READ_ERROR, MARKDOWN_COMPILE_ERROR, diff --git a/src/integrations/limits.ts b/src/integrations/limits.ts index 4a2e28f3a2..9055c14dff 100644 --- a/src/integrations/limits.ts +++ b/src/integrations/limits.ts @@ -28,6 +28,9 @@ export const MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS = 1_000; /** Maximum exact catalog tool grants admitted into one local integration source. */ export const MAX_LOCAL_INTEGRATION_TOOLS = 256; +/** Maximum canonical environment-variable name accepted from local catalog metadata. */ +export const MAX_LOCAL_INTEGRATION_CREDENTIAL_NAME_LENGTH = 128; + /** Maximum caller or environment credential length admitted into an HTTP header. */ export const MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH = 16_384; diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index 589f8dffae..89efe3e98c 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -5,6 +5,7 @@ import { assertEquals, assertInstanceOf, assertRejects, + assertThrows, } from "#veryfront/testing/assert.ts"; import { describe, it } from "#veryfront/testing/bdd.ts"; import { connectors } from "./_data.ts"; @@ -13,6 +14,7 @@ import { resolveLocalCredentialAuth, } from "./local-credential-auth.ts"; import type { LocalIntegrationCredentialProvider } from "./local-tool-source.ts"; +import type { IntegrationConfig } from "./schema.ts"; const SECRET = "LOCAL_PROVIDER_SECRET_MUST_NOT_LEAK"; const defineProperty = Object.defineProperty; @@ -69,6 +71,42 @@ function providerFrom(values: Record): LocalIntegrationCredentia } describe("local integration credential auth", () => { + it("rejects noncanonical credential names and unsupported token auth methods", () => { + const invalidCredential = { + name: "vercel", + auth: { + type: "api-key", + keyName: "not canonical?", + }, + envVars: [], + } satisfies Pick; + const credentialError = assertThrows( + () => createLocalCredentialAuthPlan(invalidCredential), + VeryfrontError, + ); + assertInstanceOf(credentialError, VeryfrontError); + assertEquals(credentialError.slug, "local-integration-config-invalid"); + + for (const tokenAuthMethod of ["none", "body", "client_secret_basic"]) { + const invalidOAuth = { + name: "paypal", + auth: { + type: "oauth2", + grantType: "client_credentials", + tokenAuthMethod, + tokenUrl: "https://oauth.example.test/token", + }, + envVars: [], + } satisfies Pick; + const tokenMethodError = assertThrows( + () => createLocalCredentialAuthPlan(invalidOAuth), + VeryfrontError, + ); + assertInstanceOf(tokenMethodError, VeryfrontError); + assertEquals(tokenMethodError.slug, "local-integration-config-invalid"); + } + }); + it("resolves header API-key and additional-header plans", async () => { const vercelPlan = createLocalCredentialAuthPlan(connector("vercel")); assertEquals(vercelPlan.requiredEnvironmentVariables, ["VERCEL_TOKEN"]); diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index 357c56a659..82d89d5cf5 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -10,7 +10,10 @@ import { executeLocalIntegrationJsonRequest, type LocalIntegrationEndpointTransport, } from "./local-endpoint-executor.ts"; -import { MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH } from "./limits.ts"; +import { + MAX_LOCAL_INTEGRATION_CREDENTIAL_NAME_LENGTH, + MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH, +} from "./limits.ts"; const apply = Reflect.apply; const arrayIsArray = Array.isArray; @@ -221,6 +224,33 @@ function declaredFallback( return undefined; } +function assertCanonicalCredentialName(value: string, connectorName: string): string { + if (value.length === 0 || value.length > MAX_LOCAL_INTEGRATION_CREDENTIAL_NAME_LENGTH) { + localIntegrationConfigurationError( + `Local integration "${connectorName}" has an invalid credential name`, + ); + } + for (let index = 0; index < value.length; index++) { + const code = apply(stringCharCodeAt, value, [index]) as number; + const allowed = code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || + (index > 0 && code >= 48 && code <= 57); + if (!allowed) { + localIntegrationConfigurationError( + `Local integration "${connectorName}" has an invalid credential name`, + ); + } + } + return value; +} + +function canonicalCredentialNames(values: readonly string[], connectorName: string): string[] { + const canonical: string[] = []; + for (let index = 0; index < values.length; index++) { + append(canonical, assertCanonicalCredentialName(values[index]!, connectorName)); + } + return canonical; +} + /** Build a serializable, value-free credential plan from trusted catalog metadata. */ export function createLocalCredentialAuthPlan( connector: Pick, @@ -253,15 +283,18 @@ export function createLocalCredentialAuthPlan( ); } const additionalHeaders = freeze({ ...auth.additionalHeaders }); - const required = [auth.keyName]; + const required = [assertCanonicalCredentialName(auth.keyName, connector.name)]; const additionalNames = objectValues(additionalHeaders); for (let index = 0; index < additionalNames.length; index++) { - append(required, additionalNames[index]!); + append( + required, + assertCanonicalCredentialName(additionalNames[index]!, connector.name), + ); } return freeze({ kind: "api-key", connectorName: connector.name, - keyName: auth.keyName, + keyName: required[0]!, headerName: auth.headerName ?? "Authorization", headerPrefix: auth.headerPrefix, additionalHeaders, @@ -276,17 +309,22 @@ export function createLocalCredentialAuthPlan( ); } const additionalHeaders = freeze({ ...auth.additionalHeaders }); - const required = [auth.usernameKey, auth.passwordKey]; + const usernameName = assertCanonicalCredentialName(auth.usernameKey, connector.name); + const passwordName = assertCanonicalCredentialName(auth.passwordKey, connector.name); + const required = [usernameName, passwordName]; const additionalNames = objectValues(additionalHeaders); for (let index = 0; index < additionalNames.length; index++) { - append(required, additionalNames[index]!); + append( + required, + assertCanonicalCredentialName(additionalNames[index]!, connector.name), + ); } return freeze({ kind: "basic", connectorName: connector.name, - usernameName: auth.usernameKey, - passwordName: auth.passwordKey, - passwordFallback: declaredFallback(connector, auth.passwordKey), + usernameName, + passwordName, + passwordFallback: declaredFallback(connector, passwordName), additionalHeaders, requiredEnvironmentVariables: freeze(required), }); @@ -301,20 +339,30 @@ export function createLocalCredentialAuthPlan( const prefix = normalizedConnectorPrefix(connector.name); const clientIdName = `${prefix}_CLIENT_ID`; const clientSecretName = `${prefix}_CLIENT_SECRET`; - const requestBodyAuth = auth.tokenAuthMethod === "post" || - auth.tokenAuthMethod === "request_body"; + let tokenAuthMethod: LocalClientCredentialsAuthPlan["tokenAuthMethod"]; + if (auth.tokenAuthMethod === "basic") tokenAuthMethod = "basic"; + else if (auth.tokenAuthMethod === "request_body") tokenAuthMethod = "request-body"; + else { + localIntegrationConfigurationError( + `Local integration "${connector.name}" uses an unsupported token authentication method`, + ); + } + const required = canonicalCredentialNames( + [clientIdName, clientSecretName], + connector.name, + ); return freeze({ kind: "client-credentials", connectorName: connector.name, clientIdName, clientSecretName, scopes: freeze(copyStrings(auth.scopes ?? [])), - tokenAuthMethod: requestBodyAuth ? "request-body" : "basic", + tokenAuthMethod, tokenUrl: assertFixedHttpsUrl( auth.tokenUrl, `Local integration "${connector.name}" token URL`, ), - requiredEnvironmentVariables: freeze([clientIdName, clientSecretName]), + requiredEnvironmentVariables: freeze(required), }); } diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index 0e09354e43..855b210180 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -155,6 +155,21 @@ describe("local integration endpoint executor", () => { }, ); + it("returns null for a successful response with no representation", async () => { + const result = await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "POST", + url: "https://api.example.test/items/item-1/pause", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport: () => Promise.resolve(new Response(null, { status: 204 })), + }); + + assertEquals(result, null); + }); + it("supports passthrough JSON bodies and Microsoft Graph query formatting", async () => { let requestBody: BodyInit | null | undefined; let requestUrl = ""; diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 566edecacb..5ea0a06f01 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -1,3 +1,4 @@ +import { INITIALIZATION_ERROR } from "#veryfront/errors"; import { snapshotBoundedJsonValue } from "#veryfront/schemas/json-value.ts"; import { guardedEgressFetch } from "#veryfront/security/sandbox/worker-egress-guard.ts"; import { readResponseTextPrefix } from "#veryfront/utils/response-body.ts"; @@ -84,7 +85,9 @@ if ( typeof urlOrigin !== "function" || typeof urlSearchParams !== "function" ) { - throw new TypeError("Local integration HTTP primitives are unavailable"); + throw INITIALIZATION_ERROR.create({ + detail: "Local integration HTTP primitives are unavailable", + }); } /** A fully constructed request admitted to the local integration transport. */ @@ -322,6 +325,34 @@ function assertKnownArguments( } } +/** @internal Snapshot and validate tool arguments before any credential or network work. */ +export function snapshotLocalIntegrationEndpointArguments( + endpoint: IntegrationEndpoint, + args: Record, +): Record { + const snapshot = snapshotArguments(args); + assertKnownArguments(snapshot, endpoint); + + const paramNames = objectKeys(endpoint.params ?? {}); + for (let index = 0; index < paramNames.length; index++) { + const name = paramNames[index]!; + const field = endpoint.params?.[name]; + if (!field) continue; + const resolved = fieldValue(snapshot, name, field); + if (resolved.present && (field.in === "path" || field.in === "header")) { + scalarString(resolved.value); + } + } + + const bodyNames = objectKeys(endpoint.body ?? {}); + for (let index = 0; index < bodyNames.length; index++) { + const name = bodyNames[index]!; + const field = endpoint.body?.[name]; + if (field) fieldValue(snapshot, name, field); + } + return snapshot; +} + function serializeJson(value: unknown): string { const snapshot = snapshotBoundedJsonValue(value); if (!snapshot.success) requestInvalid("Local integration request body must be bounded JSON"); @@ -565,6 +596,7 @@ async function executeTransportRequest( } requestFailed(identity, status); } + if (status === 204) return freeze({ status, value: null }); return freeze({ status, value: await readResponseJson(response, signal, identity, status), @@ -596,7 +628,7 @@ function transformResponse( export async function executeLocalIntegrationEndpoint( options: ExecuteLocalIntegrationEndpointOptions, ): Promise { - const args = snapshotArguments(options.args); + const args = snapshotLocalIntegrationEndpointArguments(options.endpoint, options.args); const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, diff --git a/src/integrations/local-integration-errors.ts b/src/integrations/local-integration-errors.ts index bfa60aac0a..6bf4173fe1 100644 --- a/src/integrations/local-integration-errors.ts +++ b/src/integrations/local-integration-errors.ts @@ -1,56 +1,21 @@ -import { defineError } from "#veryfront/errors"; +import { + LOCAL_INTEGRATION_CONFIG_INVALID, + LOCAL_INTEGRATION_REQUEST_FAILED, + LOCAL_INTEGRATION_RESPONSE_INVALID, +} from "#veryfront/errors"; + +export { + LOCAL_INTEGRATION_CONFIG_INVALID, + LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, + LOCAL_INTEGRATION_CREDENTIALS_MISSING, + LOCAL_INTEGRATION_REQUEST_FAILED, + LOCAL_INTEGRATION_REQUEST_INVALID, + LOCAL_INTEGRATION_RESPONSE_INVALID, +} from "#veryfront/errors"; const apply = Reflect.apply; const stringCharCodeAt = String.prototype.charCodeAt; -export const LOCAL_INTEGRATION_CONFIG_INVALID = defineError({ - slug: "local-integration-config-invalid", - category: "CONFIG", - status: 400, - title: "Invalid local integration configuration", - suggestion: "Use exact catalog tool IDs and supported local credential and endpoint contracts", -}); - -export const LOCAL_INTEGRATION_CREDENTIALS_MISSING = defineError({ - slug: "local-integration-credentials-missing", - category: "CONFIG", - status: 400, - title: "Local integration credentials are missing", - suggestion: "Set the named environment variables or configure a credential provider", -}); - -export const LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE = defineError({ - slug: "local-integration-credential-unavailable", - category: "RUNTIME", - status: 503, - title: "Local integration credential is unavailable", - suggestion: "Check the local credential provider and retry", -}); - -export const LOCAL_INTEGRATION_REQUEST_INVALID = defineError({ - slug: "local-integration-request-invalid", - category: "BOUNDARY", - status: 400, - title: "Local integration request is invalid", - suggestion: "Pass only the documented tool arguments with their declared JSON types", -}); - -export const LOCAL_INTEGRATION_REQUEST_FAILED = defineError({ - slug: "local-integration-request-failed", - category: "RUNTIME", - status: 502, - title: "Local integration request failed", - suggestion: "Check the provider status and local integration configuration, then retry", -}); - -export const LOCAL_INTEGRATION_RESPONSE_INVALID = defineError({ - slug: "local-integration-response-invalid", - category: "RUNTIME", - status: 502, - title: "Local integration response is invalid", - suggestion: "Check the provider response contract and retry", -}); - export interface LocalIntegrationDiagnosticIdentity { readonly connectorName: string; readonly toolId: string; diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 348e8105f8..6f9ddf6b86 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -407,6 +407,34 @@ describe("createLocalIntegrationToolSource", () => { ]); }); + it("rejects invalid tool arguments before resolving or minting credentials", async () => { + let credentialProviderCalls = 0; + let transportCalls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["paypal__list_balances"], + credentialProvider: () => { + credentialProviderCalls += 1; + return TEST_CREDENTIAL; + }, + }, + () => { + transportCalls += 1; + return Promise.resolve(Response.json({ access_token: TEST_CREDENTIAL })); + }, + ); + + const error = await assertRejects( + () => source.executeTool("paypal__list_balances", { unknown: true }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + assertEquals(credentialProviderCalls, 0); + assertEquals(transportCalls, 0); + }); + it("uses only a validated Salesforce instance origin from service-account tokens", async () => { const requests: string[] = []; const transport: LocalIntegrationEndpointTransport = (request) => { diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index d9af9d0cde..c13d2ccaaa 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -17,6 +17,7 @@ import { import { executeLocalIntegrationEndpoint, type LocalIntegrationEndpointTransport, + snapshotLocalIntegrationEndpointArguments, } from "./local-endpoint-executor.ts"; import { localIntegrationConfigurationError } from "./local-integration-errors.ts"; import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; @@ -516,6 +517,7 @@ function createLocalIntegrationToolSourceInternal( if (!tool) { configurationError(`Local integration tool "${toolName}" is not granted by this source`); } + const validatedArgs = snapshotLocalIntegrationEndpointArguments(tool.endpoint, args); const auth = await mintLocalCredentialAuth( await resolveLocalCredentialAuth(tool.authPlan, credentialProvider), toolName, @@ -544,7 +546,7 @@ function createLocalIntegrationToolSourceInternal( connectorName: tool.connector.name, toolId: toolName, endpoint, - args, + args: validatedArgs, authHeaders: auth.headers, allowedOrigin, signal: context?.abortSignal, diff --git a/tests/docs/guide-code-examples.test.ts b/tests/docs/guide-code-examples.test.ts index 070b8d7ba3..dcd4ced314 100644 --- a/tests/docs/guide-code-examples.test.ts +++ b/tests/docs/guide-code-examples.test.ts @@ -62,7 +62,7 @@ import { getRemoteIntegrationToolDefinitions, listConnectors, } from "../../src/integrations/index.ts"; -import { loadRemoteToolsFromSource } from "../../src/tool/index.ts"; +import { loadRemoteToolsFromSource } from "#veryfront/tool"; import { parseDeployArgs } from "../../cli/commands/deploy/command.ts"; import { buildKnowledgeIngestRunResult } from "../../cli/commands/knowledge/result.ts"; import { parsePullArgs } from "../../cli/commands/pull/command.ts"; From b18cc144fac0fef51ebf7c90d2f9ce64c84953b3 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 06:42:05 +0200 Subject: [PATCH 11/25] Keep documentation contracts independent of process cwd The local-integration guide assertions now resolve their files from the test module URL, preserving deterministic reads when parallel tests temporarily change the shared process directory. Constraint: Parallel test isolates share process cwd and the lint baseline cannot increase. Rejected: Raise the cwd-relative-read baseline | would preserve a known race instead of removing it. Confidence: high Scope-risk: narrow Directive: Resolve repository fixtures from import.meta.url in test callbacks. Tested: lint:cwd-relative-test-reads; guide-content.test.ts; fmt; lint; check; diff-check Not-tested: Full suite deferred to the existing pre-push hook and replacement CI. --- tests/docs/guide-content.test.ts | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/tests/docs/guide-content.test.ts b/tests/docs/guide-content.test.ts index ea5938db60..2033143d00 100644 --- a/tests/docs/guide-content.test.ts +++ b/tests/docs/guide-content.test.ts @@ -286,11 +286,15 @@ describe("guide content contracts", () => { }); it("documents account-free local integration credentials without weakening grants", async () => { - const integrations = await Deno.readTextFile("docs/guides/integrations.md"); + const integrations = await Deno.readTextFile( + new URL("docs/guides/integrations.md", repoRoot), + ); const salesforce = await Deno.readTextFile( - "docs/guides/integrations/salesforce.md", + new URL("docs/guides/integrations/salesforce.md", repoRoot), + ); + const selfHosting = await Deno.readTextFile( + new URL("docs/guides/self-hosting.md", repoRoot), ); - const selfHosting = await Deno.readTextFile("docs/guides/self-hosting.md"); const docs = [integrations, salesforce, selfHosting].join("\n"); assertStringIncludes(docs, "createLocalIntegrationToolSource"); From fb75b784d1c54b69ec246cd40e9665467ec0dada Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 07:13:35 +0200 Subject: [PATCH 12/25] fix(integrations): honor catalog token contracts --- .../local-credential-auth.test.ts | 55 ++++++++------ src/integrations/local-credential-auth.ts | 75 +++++++++++++++---- .../local-endpoint-executor.test.ts | 7 +- 3 files changed, 98 insertions(+), 39 deletions(-) diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index 89efe3e98c..4a8331d457 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -47,19 +47,6 @@ function replaceProperty( }; } -function replaceDescriptor( - target: object, - key: PropertyKey, - descriptor: PropertyDescriptor, -): () => void { - const previous = getOwnPropertyDescriptor(target, key); - defineProperty(target, key, descriptor); - return () => { - if (previous) defineProperty(target, key, previous); - else deleteProperty(target, key); - }; -} - function connector(name: string) { const value = connectors.find((candidate) => candidate.name === name); assert(value, `Missing test connector ${name}`); @@ -203,6 +190,34 @@ describe("local integration credential auth", () => { assertEquals(resolved.body, "grant_type=client_credentials"); }); + it("uses catalog-declared client credential names when the connector prefix differs", () => { + const plan = createLocalCredentialAuthPlan(connector("trusted-shops")); + + assertEquals(plan.requiredEnvironmentVariables, [ + "ETRUSTED_CLIENT_ID", + "ETRUSTED_CLIENT_SECRET", + ]); + }); + + it("includes catalog-declared parameters in client-credentials token requests", async () => { + const plan = createLocalCredentialAuthPlan(connector("trusted-shops")); + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + ETRUSTED_CLIENT_ID: "trusted-shops-client", + ETRUSTED_CLIENT_SECRET: SECRET, + TRUSTED_SHOPS_CLIENT_ID: "trusted-shops-client", + TRUSTED_SHOPS_CLIENT_SECRET: SECRET, + }), + ); + + assert(resolved.kind === "token-request"); + assertEquals( + resolved.body, + `grant_type=client_credentials&client_id=trusted-shops-client&client_secret=${SECRET}&audience=https%3A%2F%2Fapi.etrusted.com`, + ); + }); + it("builds a Salesforce service-account token request from its distinct vocabulary", async () => { const plan = createLocalCredentialAuthPlan(connector("salesforce")); assertEquals(plan.requiredEnvironmentVariables, [ @@ -249,7 +264,9 @@ describe("local integration credential auth", () => { appendRestorer(restorers, replaceProperty(Array, "isArray", poison)); appendRestorer(restorers, replaceProperty(Array.prototype, "indexOf", poison)); appendRestorer(restorers, replaceProperty(Array.prototype, "join", poison)); - appendRestorer(restorers, replaceProperty(Array.prototype, "push", poison)); + // node:test uses Array.prototype.push while this async test is + // suspended, so poisoning it would fail the host test harness rather + // than exercise credential resolution. appendRestorer(restorers, replaceProperty(Array.prototype, "splice", poison)); appendRestorer(restorers, replaceProperty(Object, "create", poison)); appendRestorer(restorers, replaceProperty(Object, "entries", poison)); @@ -261,13 +278,9 @@ describe("local integration credential auth", () => { appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "toLowerCase", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "trim", poison)); - appendRestorer( - restorers, - replaceDescriptor(Array.prototype, "0", { - configurable: true, - set: poison, - }), - ); + // node:test also appends diagnostics to empty arrays while this async + // test is suspended, so an inherited index-0 setter would fail the host + // harness before the framework assertion can run. paypal = await resolveLocalCredentialAuth( createLocalCredentialAuthPlan(paypalConnector), diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index 82d89d5cf5..3669e2a2d6 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -28,7 +28,6 @@ const objectValues = Object.values; const stringCharCodeAt = String.prototype.charCodeAt; const stringEndsWith = String.prototype.endsWith; const stringIncludes = String.prototype.includes; -const stringFromCharCode = String.fromCharCode; const stringToLowerCase = String.prototype.toLowerCase; const stringTrim = String.prototype.trim; const textEncoder = new TextEncoder(); @@ -67,6 +66,7 @@ interface LocalBasicAuthPlan extends LocalCredentialAuthPlanBase { interface LocalClientCredentialsAuthPlan extends LocalCredentialAuthPlanBase { readonly kind: "client-credentials"; + readonly additionalParams: Readonly>; readonly clientIdName: string; readonly clientSecretName: string; readonly scopes: readonly string[]; @@ -200,17 +200,6 @@ function assertFixedHttpsUrl(value: string, label: string): string { return value; } -function normalizedConnectorPrefix(name: string): string { - let prefix = ""; - for (let index = 0; index < name.length; index++) { - const code = apply(stringCharCodeAt, name, [index]) as number; - if (code >= 97 && code <= 122) prefix += stringFromCharCode(code - 32); - else if (code >= 65 && code <= 90 || code >= 48 && code <= 57) prefix += name[index]; - else prefix += "_"; - } - return prefix; -} - function declaredFallback( connector: Pick, name: string, @@ -251,6 +240,56 @@ function canonicalCredentialNames(values: readonly string[], connectorName: stri return canonical; } +function declaredClientCredentialName( + connector: Pick, + suffix: "_CLIENT_ID" | "_CLIENT_SECRET", +): string { + let matched: string | undefined; + for (let index = 0; index < (connector.envVars?.length ?? 0); index++) { + const name = connector.envVars?.[index]?.name; + if (typeof name !== "string" || !stringEndsWithValue(name, suffix)) continue; + if (matched !== undefined) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" declares multiple ${suffix} credentials`, + ); + } + matched = assertCanonicalCredentialName(name, connector.name); + } + if (matched === undefined) { + localIntegrationConfigurationError( + `Local integration "${connector.name}" is missing its ${suffix} credential`, + ); + } + return matched; +} + +function copyTokenParams( + values: Readonly> | undefined, + connectorName: string, +): Record { + const copied: Record = objectCreate(null); + const entries = objectEntries(values ?? {}); + for (let index = 0; index < entries.length; index++) { + const [name, value] = entries[index]!; + if ( + name.length === 0 || typeof value !== "string" || + name === "grant_type" || name === "client_id" || name === "client_secret" || + name === "scope" + ) { + localIntegrationConfigurationError( + `Local integration "${connectorName}" declares an invalid token parameter`, + ); + } + objectDefineProperty(copied, name, { + configurable: true, + enumerable: true, + value, + writable: true, + }); + } + return copied; +} + /** Build a serializable, value-free credential plan from trusted catalog metadata. */ export function createLocalCredentialAuthPlan( connector: Pick, @@ -336,9 +375,9 @@ export function createLocalCredentialAuthPlan( `Local integration "${connector.name}" requires a fixed token URL`, ); } - const prefix = normalizedConnectorPrefix(connector.name); - const clientIdName = `${prefix}_CLIENT_ID`; - const clientSecretName = `${prefix}_CLIENT_SECRET`; + const clientIdName = declaredClientCredentialName(connector, "_CLIENT_ID"); + const clientSecretName = declaredClientCredentialName(connector, "_CLIENT_SECRET"); + const additionalParams = freeze(copyTokenParams(auth.additionalParams, connector.name)); let tokenAuthMethod: LocalClientCredentialsAuthPlan["tokenAuthMethod"]; if (auth.tokenAuthMethod === "basic") tokenAuthMethod = "basic"; else if (auth.tokenAuthMethod === "request_body") tokenAuthMethod = "request-body"; @@ -354,6 +393,7 @@ export function createLocalCredentialAuthPlan( return freeze({ kind: "client-credentials", connectorName: connector.name, + additionalParams, clientIdName, clientSecretName, scopes: freeze(copyStrings(auth.scopes ?? [])), @@ -584,6 +624,11 @@ export async function resolveLocalCredentialAuth( } else { headers.Authorization = `Basic ${base64(`${clientId}:${clientSecret}`)}`; } + const additionalEntries = objectEntries(plan.additionalParams); + for (let index = 0; index < additionalEntries.length; index++) { + const [name, value] = additionalEntries[index]!; + append(body, formEntry(name, value)); + } return freeze({ kind: "token-request", connectorName: plan.connectorName, diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index 855b210180..9f3386f488 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -243,12 +243,13 @@ describe("local integration endpoint executor", () => { appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); appendRestorer(restorers, replaceProperty(Object, "keys", poison)); appendRestorer(restorers, replaceProperty(Reflect, "getOwnPropertyDescriptor", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); + // Node's native Headers implementation reads String, charCodeAt, and + // includes from the host realm inside Headers.prototype.set. Poisoning + // those makes the captured host constructor itself unusable, so this + // test limits its assertion to framework-owned traversal. appendRestorer(restorers, replaceProperty(String.prototype, "replaceAll", poison)); appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); appendRestorer(restorers, replaceProperty(globalThis, "setTimeout", poison)); - appendRestorer(restorers, replaceProperty(globalThis, "String", poison)); appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); try { From 9ab5b172b9fe0fe7dcec0d0b1a2dc44e6d1730ef Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 07:25:08 +0200 Subject: [PATCH 13/25] docs(integrations): align credential contract --- .../2026-08-18-local-integration-credentials-design.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md b/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md index 6254749029..ded87cf7a7 100644 --- a/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md +++ b/docs/superpowers/specs/2026-08-18-local-integration-credentials-design.md @@ -150,9 +150,10 @@ boundary. ### OAuth2 client credentials Only connectors with `grantType: "client_credentials"` are eligible. Credential names derive from -the existing connector vocabulary: `_CLIENT_ID` and -`_CLIENT_SECRET`. The source supports fixed HTTPS token URLs and the catalog's -Basic or request-body client-auth method. Authorization-code connectors remain unsupported. +the connector's declared environment metadata. The source selects the single names ending in +`_CLIENT_ID` and `_CLIENT_SECRET` and fails closed when either name is missing or ambiguous. It +supports fixed HTTPS token URLs and the catalog's Basic or request-body client-auth method. +Authorization-code connectors remain unsupported. ### Salesforce service account From 5fe6ca2cff6529e818d1ca118bf9031d5f9ca022 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 07:52:04 +0200 Subject: [PATCH 14/25] fix(integrations): harden local credential execution --- docs/api-reference/veryfront/integrations.md | 6 +- .../local-credential-auth.test.ts | 25 ++++++++ src/integrations/local-credential-auth.ts | 25 ++++++-- .../local-endpoint-executor.test.ts | 60 ++++++++++++++++--- src/integrations/local-endpoint-executor.ts | 50 ++++++++++++---- src/integrations/local-tool-source.test.ts | 34 +++++++++++ src/integrations/local-tool-source.ts | 24 +++++--- 7 files changed, 188 insertions(+), 36 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index fbbb63e1b1..e8fdd8fd7d 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -54,7 +54,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L560) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L570) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L51) | | `getConnectorNames` | Return connector names. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L62) | @@ -76,8 +76,8 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | | `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | | `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L54) | -| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L59) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L55) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L60) | | `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | | `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | | `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index 4a8331d457..cd715d7bfe 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -190,6 +190,31 @@ describe("local integration credential auth", () => { assertEquals(resolved.body, "grant_type=client_credentials"); }); + it("form-encodes OAuth Basic client credentials before encoding the header", async () => { + const plan = createLocalCredentialAuthPlan(connector("paypal")); + const clientId = "client id+with%reserved:characters"; + const clientSecret = "secret value+with%reserved:characters"; + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + PAYPAL_CLIENT_ID: clientId, + PAYPAL_CLIENT_SECRET: clientSecret, + }), + ); + + assert(resolved.kind === "token-request"); + const encodedClientId = new URLSearchParams({ value: clientId }).toString().slice( + "value=".length, + ); + const encodedClientSecret = new URLSearchParams({ value: clientSecret }).toString().slice( + "value=".length, + ); + assertEquals( + resolved.headers.Authorization, + `Basic ${btoa(`${encodedClientId}:${encodedClientSecret}`)}`, + ); + }); + it("uses catalog-declared client credential names when the connector prefix differs", () => { const plan = createLocalCredentialAuthPlan(connector("trusted-shops")); diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index 3669e2a2d6..ef2fa94214 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -1,19 +1,19 @@ -import type { LocalIntegrationCredentialProvider } from "./local-tool-source.ts"; -import type { IntegrationConfig } from "./schema.ts"; +import type { LocalIntegrationCredentialProvider } from "#veryfront/integrations/local-tool-source.ts"; +import type { IntegrationConfig } from "#veryfront/integrations/schema.ts"; import { LOCAL_INTEGRATION_CREDENTIAL_UNAVAILABLE, LOCAL_INTEGRATION_CREDENTIALS_MISSING, localIntegrationConfigurationError, localIntegrationResponseInvalid, -} from "./local-integration-errors.ts"; +} from "#veryfront/integrations/local-integration-errors.ts"; import { executeLocalIntegrationJsonRequest, type LocalIntegrationEndpointTransport, -} from "./local-endpoint-executor.ts"; +} from "#veryfront/integrations/local-endpoint-executor.ts"; import { MAX_LOCAL_INTEGRATION_CREDENTIAL_NAME_LENGTH, MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH, -} from "./limits.ts"; +} from "#veryfront/integrations/limits.ts"; const apply = Reflect.apply; const arrayIsArray = Array.isArray; @@ -28,11 +28,14 @@ const objectValues = Object.values; const stringCharCodeAt = String.prototype.charCodeAt; const stringEndsWith = String.prototype.endsWith; const stringIncludes = String.prototype.includes; +const stringSlice = String.prototype.slice; const stringToLowerCase = String.prototype.toLowerCase; const stringTrim = String.prototype.trim; const textEncoder = new TextEncoder(); const textEncoderEncode = TextEncoder.prototype.encode; const URLConstructor = URL; +const URLSearchParamsConstructor = URLSearchParams; +const urlSearchParamsToString = URLSearchParams.prototype.toString; const urlHash = getOwnPropertyDescriptor(URL.prototype, "hash")?.get; const urlHostname = getOwnPropertyDescriptor(URL.prototype, "hostname")?.get; const urlOrigin = getOwnPropertyDescriptor(URL.prototype, "origin")?.get; @@ -439,6 +442,12 @@ function formEntry(name: string, value: string): string { return `${encodeUriComponent(name)}=${encodeUriComponent(value)}`; } +function formComponent(value: string): string { + const params = new URLSearchParamsConstructor([["value", value]]); + const serialized = apply(urlSearchParamsToString, params, []) as string; + return apply(stringSlice, serialized, ["value=".length]) as string; +} + async function readCredential( provider: LocalIntegrationCredentialProvider, connectorName: string, @@ -622,7 +631,11 @@ export async function resolveLocalCredentialAuth( append(body, formEntry("client_id", clientId)); append(body, formEntry("client_secret", clientSecret)); } else { - headers.Authorization = `Basic ${base64(`${clientId}:${clientSecret}`)}`; + headers.Authorization = `Basic ${ + base64( + `${formComponent(clientId)}:${formComponent(clientSecret)}`, + ) + }`; } const additionalEntries = objectEntries(plan.additionalParams); for (let index = 0; index < additionalEntries.length; index++) { diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index 9f3386f488..9b4ee42ed6 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -5,6 +5,7 @@ import { assertEquals, assertInstanceOf, assertRejects, + assertStrictEquals, } from "#veryfront/testing/assert.ts"; import { describe, it } from "#veryfront/testing/bdd.ts"; import type { IntegrationToolMeta } from "./schema.ts"; @@ -449,8 +450,34 @@ describe("local integration endpoint executor", () => { } }); - it("enforces its deadline and caller cancellation without leaking abort reasons", async () => { + it("cancels a response rejected by its declared size", async () => { + const response = new Response("{}", { + headers: { "content-length": String(4 * 1024 * 1024 + 1) }, + }); + + const error = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/items", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport: () => Promise.resolve(response), + }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-response-invalid"); + assertEquals(response.bodyUsed, true); + }); + + it("enforces its deadline and propagates caller cancellation", async () => { const abortController = new AbortController(); + const abortReason = new DOMException("caller stopped", "AbortError"); const pending = executeLocalIntegrationEndpoint({ endpoint: endpoint({ method: "GET", @@ -470,13 +497,32 @@ describe("local integration endpoint executor", () => { ); }), }); - abortController.abort(new Error(SECRET)); + abortController.abort(abortReason); - const error = await assertRejects(() => pending, VeryfrontError); - assertInstanceOf(error, VeryfrontError); - assertEquals(error.slug, "local-integration-request-failed"); - assertEquals(error.message.includes(SECRET), false); - assertEquals(error.cause, undefined); + assertStrictEquals(await assertRejects(() => pending), abortReason); + + const preAbortedController = new AbortController(); + const preAbortedReason = new DOMException("already stopped", "AbortError"); + preAbortedController.abort(preAbortedReason); + let transportCalls = 0; + const preAbortedError = await assertRejects(() => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/slow", + }), + args: {}, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + signal: preAbortedController.signal, + transport: () => { + transportCalls += 1; + return Promise.resolve(Response.json({ unexpected: true })); + }, + }) + ); + assertStrictEquals(preAbortedError, preAbortedReason); + assertEquals(transportCalls, 0); const timeoutError = await assertRejects( () => diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 5ea0a06f01..e0de5d5651 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -7,12 +7,12 @@ import { type LocalIntegrationDiagnosticIdentity, localIntegrationRequestFailed, localIntegrationResponseInvalid, -} from "./local-integration-errors.ts"; +} from "#veryfront/integrations/local-integration-errors.ts"; import { INTEGRATION_REQUEST_TIMEOUT_MS, MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES, -} from "./limits.ts"; -import type { IntegrationToolMeta } from "./schema.ts"; +} from "#veryfront/integrations/limits.ts"; +import type { IntegrationToolMeta } from "#veryfront/integrations/schema.ts"; type IntegrationEndpoint = NonNullable; type IntegrationEndpointParam = NonNullable[string]; @@ -32,6 +32,7 @@ const abortSignalReason = Object.getOwnPropertyDescriptor( AbortSignal.prototype, "reason", )?.get; +const abortSignalThrowIfAborted = AbortSignal.prototype.throwIfAborted; const addEventListener = EventTarget.prototype.addEventListener; const apply = Reflect.apply; const arrayIsArray = Array.isArray; @@ -77,6 +78,7 @@ const typedArrayByteLength = Object.getOwnPropertyDescriptor( if ( typeof abortSignalAborted !== "function" || typeof abortSignalReason !== "function" || + typeof abortSignalThrowIfAborted !== "function" || typeof abortControllerSignal !== "function" || typeof responseBody !== "function" || typeof responseHeaders !== "function" || @@ -184,6 +186,10 @@ function controllerSignalValue(controller: AbortController): AbortSignal { return apply(abortControllerSignal, controller, []) as AbortSignal; } +function throwIfCallerAborted(signal: AbortSignal | undefined): void { + if (signal) apply(abortSignalThrowIfAborted, signal, []); +} + function responseStatusValue(response: Response): number { if (!responseStatus) requestFailed(); return apply(responseStatus, response, []) as number; @@ -535,13 +541,27 @@ function decodedByteLength(value: string): number { return apply(typedArrayByteLength, encoded, []) as number; } +function cancelResponseBody(response: Response): void { + try { + const body = responseBodyValue(response); + if (!body) return; + const cancellation = apply(readableStreamCancel, body, []) as Promise; + void apply(promiseCatch, cancellation, [() => undefined]); + } catch { + // Response cleanup is best effort and must not expose provider errors. + } +} + async function readResponseJson( response: Response, signal: AbortSignal, identity: LocalIntegrationDiagnosticIdentity, status: number, ): Promise { - if (!contentLengthWithinLimit(response)) responseInvalid(identity, status); + if (!contentLengthWithinLimit(response)) { + cancelResponseBody(response); + responseInvalid(identity, status); + } let text: string; let truncated: boolean; try { @@ -585,15 +605,7 @@ async function executeTransportRequest( } const status = responseStatusValue(response); if (status < 200 || status >= 300) { - try { - const body = responseBodyValue(response); - if (body) { - const cancellation = apply(readableStreamCancel, body, []) as Promise; - void apply(promiseCatch, cancellation, [() => undefined]); - } - } catch { - // Response cleanup is best effort and must not expose provider errors. - } + cancelResponseBody(response); requestFailed(identity, status); } if (status === 204) return freeze({ status, value: null }); @@ -628,12 +640,14 @@ function transformResponse( export async function executeLocalIntegrationEndpoint( options: ExecuteLocalIntegrationEndpointOptions, ): Promise { + throwIfCallerAborted(options.signal); const args = snapshotLocalIntegrationEndpointArguments(options.endpoint, options.args); const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, ); try { + throwIfCallerAborted(options.signal); const request = buildRequest( options.endpoint, args, @@ -647,12 +661,16 @@ export async function executeLocalIntegrationEndpoint( signalLease.signal, options, ); + throwIfCallerAborted(options.signal); return transformResponse( result.value, options.endpoint.response?.transform, options, result.status, ); + } catch (cause) { + throwIfCallerAborted(options.signal); + throw cause; } finally { signalLease.release(); } @@ -662,11 +680,13 @@ export async function executeLocalIntegrationEndpoint( export async function executeLocalIntegrationJsonRequest( options: ExecuteLocalIntegrationJsonRequestOptions, ): Promise { + throwIfCallerAborted(options.signal); const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, ); try { + throwIfCallerAborted(options.signal); let url: URL; try { url = new URLConstructor(options.url); @@ -703,7 +723,11 @@ export async function executeLocalIntegrationJsonRequest( signalLease.signal, options, ); + throwIfCallerAborted(options.signal); return result; + } catch (cause) { + throwIfCallerAborted(options.signal); + throw cause; } finally { signalLease.release(); } diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 6f9ddf6b86..d423757fb0 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -9,6 +9,7 @@ import { assertEquals, assertInstanceOf, assertRejects, + assertStrictEquals, } from "#veryfront/testing/assert.ts"; import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; import { loadRemoteToolsFromSource } from "#veryfront/tool"; @@ -435,6 +436,39 @@ describe("createLocalIntegrationToolSource", () => { assertEquals(transportCalls, 0); }); + it("rejects pre-aborted execution before resolving credentials", async () => { + let credentialProviderCalls = 0; + let transportCalls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["vercel__list_projects"], + credentialProvider: () => { + credentialProviderCalls += 1; + return TEST_CREDENTIAL; + }, + }, + () => { + transportCalls += 1; + return Promise.resolve(Response.json({ projects: [] })); + }, + ); + const controller = new AbortController(); + const reason = new DOMException("caller stopped", "AbortError"); + controller.abort(reason); + + const error = await assertRejects(() => + source.executeTool( + "vercel__list_projects", + {}, + { abortSignal: controller.signal }, + ) + ); + + assertStrictEquals(error, reason); + assertEquals(credentialProviderCalls, 0); + assertEquals(transportCalls, 0); + }); + it("uses only a validated Salesforce instance origin from service-account tokens", async () => { const requests: string[] = []; const transport: LocalIntegrationEndpointTransport = (request) => { diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index c13d2ccaaa..f1fb0fb71f 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -7,25 +7,26 @@ import type { ToolDefinition, ToolExecutionContext, } from "#veryfront/tool/types.ts"; -import { connectors } from "./_data.ts"; +import { connectors } from "#veryfront/integrations/_data.ts"; import { createLocalCredentialAuthPlan, type LocalCredentialAuthPlan, mintLocalCredentialAuth, resolveLocalCredentialAuth, -} from "./local-credential-auth.ts"; +} from "#veryfront/integrations/local-credential-auth.ts"; import { executeLocalIntegrationEndpoint, type LocalIntegrationEndpointTransport, snapshotLocalIntegrationEndpointArguments, -} from "./local-endpoint-executor.ts"; -import { localIntegrationConfigurationError } from "./local-integration-errors.ts"; -import { MAX_LOCAL_INTEGRATION_TOOLS } from "./limits.ts"; -import { parseIntegrationToolIdentity } from "./source-policy.ts"; -import type { IntegrationConfig, IntegrationToolMeta } from "./schema.ts"; +} from "#veryfront/integrations/local-endpoint-executor.ts"; +import { localIntegrationConfigurationError } from "#veryfront/integrations/local-integration-errors.ts"; +import { MAX_LOCAL_INTEGRATION_TOOLS } from "#veryfront/integrations/limits.ts"; +import { parseIntegrationToolIdentity } from "#veryfront/integrations/source-policy.ts"; +import type { IntegrationConfig, IntegrationToolMeta } from "#veryfront/integrations/schema.ts"; const apply = Reflect.apply; const arrayIsArray = Array.isArray; +const abortSignalThrowIfAborted = AbortSignal.prototype.throwIfAborted; const freeze = Object.freeze; const getOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor; const MapConstructor = Map; @@ -141,6 +142,14 @@ function mapValue(map: Map, key: K): V | undefined { return apply(mapGet, map, [key]) as V | undefined; } +function throwIfCallerAborted(signal: AbortSignal | undefined): void { + if (!signal) return; + if (typeof abortSignalThrowIfAborted !== "function") { + configurationError("AbortSignal cancellation is unavailable in this runtime"); + } + apply(abortSignalThrowIfAborted, signal, []); +} + function configurationError(detail: string): never { return localIntegrationConfigurationError(detail); } @@ -513,6 +522,7 @@ function createLocalIntegrationToolSourceInternal( context?: ToolExecutionContext, ): Promise { assertLocalRuntime(); + throwIfCallerAborted(context?.abortSignal); const tool = mapValue(admitted, toolName); if (!tool) { configurationError(`Local integration tool "${toolName}" is not granted by this source`); From d8b9d0d44460c23005516a2cb25b82ece60737db Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 19:44:25 +0200 Subject: [PATCH 15/25] fix(integrations): harden local-credential shapes and defer catalog capture Addresses the four open review findings: - readCredential fails closed on values with control characters or edge whitespace, which fetch would otherwise reject as an opaque header error far from the credential's name - a Basic-auth username containing a colon is reported as a missing credential: RFC 7617 splits the credential at the first colon, so part of the username would silently become password - the local integration catalog is captured on first admitTool use instead of at module load, so invalid catalog metadata cannot prevent the integrations barrel from importing - the cross-runtime local-tool-source test uses setEnv/deleteEnv from testing/deno-compat instead of direct Deno.env, which excluded the file from the Node and Bun runners - the self-hosting capability row is renamed to "Integration tools": a local catalog source materializes local tools rather than providing the remote-tools path --- docs/guides/self-hosting.md | 2 +- .../local-credential-auth.test.ts | 31 ++++++++++++++++++- src/integrations/local-credential-auth.ts | 25 +++++++++++++-- src/integrations/local-tool-source.test.ts | 5 +-- src/integrations/local-tool-source.ts | 15 +++++++-- tests/docs/guide-content.test.ts | 2 +- tests/docs/guide-contracts.test.ts | 2 +- 7 files changed, 71 insertions(+), 11 deletions(-) diff --git a/docs/guides/self-hosting.md b/docs/guides/self-hosting.md index 792897063f..7bc22a7b80 100644 --- a/docs/guides/self-hosting.md +++ b/docs/guides/self-hosting.md @@ -25,7 +25,7 @@ Choose substitutes for managed capabilities before you deploy. | Local agent delegation with `delegates` | Supported | Delegates run in the application process. | | Workflows | Supported | Use the in-memory backend or configure Redis for shared durable state. | | Source-controlled project knowledge | Supported | Use the local project directory and the project knowledge tools. | -| Remote integration tools | Supported subset | Use a local source or managed backing API. | +| Integration tools | Supported subset | Use a local catalog source or a managed backing API. | | Sandbox sessions | Requires a backing API or service layer | Configure authenticated sandbox session APIs. | | Veryfront Cloud routing, storage, and runs | Requires Veryfront Cloud | These capabilities depend on project and control-plane context. | diff --git a/src/integrations/local-credential-auth.test.ts b/src/integrations/local-credential-auth.test.ts index cd715d7bfe..e2fc022057 100644 --- a/src/integrations/local-credential-auth.test.ts +++ b/src/integrations/local-credential-auth.test.ts @@ -373,9 +373,38 @@ describe("local integration credential auth", () => { ); }); + it("rejects a Basic username containing a colon and keeps colons in passwords", async () => { + // RFC 7617 splits the credential at the first `:`, so a colon in the + // user-id would silently shift part of the username into the password. + const plan = createLocalCredentialAuthPlan(connector("sendcloud")); + const error = await assertRejects( + () => + resolveLocalCredentialAuth( + plan, + providerFrom({ + SENDCLOUD_PUBLIC_KEY: "user:name", + SENDCLOUD_SECRET_KEY: SECRET, + }), + ), + VeryfrontError, + ); + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-credentials-missing"); + assert(error.message.includes("SENDCLOUD_PUBLIC_KEY"), error.message); + + const resolved = await resolveLocalCredentialAuth( + plan, + providerFrom({ + SENDCLOUD_PUBLIC_KEY: "public-key", + SENDCLOUD_SECRET_KEY: "pass:word", + }), + ); + assertEquals(resolved.kind, "headers"); + }); + it("fails safely for invalid values, provider failures, and Salesforce login URLs", async () => { const plan = createLocalCredentialAuthPlan(connector("vercel")); - for (const value of ["", " ", "x".repeat(16_385)]) { + for (const value of ["", " ", " token", "token ", "token\n", "tok\ten", "x".repeat(16_385)]) { const error = await assertRejects( () => resolveLocalCredentialAuth(plan, () => value), VeryfrontError, diff --git a/src/integrations/local-credential-auth.ts b/src/integrations/local-credential-auth.ts index ef2fa94214..d5058d2d6e 100644 --- a/src/integrations/local-credential-auth.ts +++ b/src/integrations/local-credential-auth.ts @@ -463,9 +463,20 @@ async function readCredential( } if (typeof value !== "string") return undefined; const trimmed = stringCall(stringTrim, value); - if (trimmed.length === 0 || value.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH) { + if ( + trimmed.length === 0 || trimmed.length !== value.length || + value.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH + ) { return undefined; } + // A control character or edge whitespace in a header value makes fetch + // reject the request as an opaque runtime error instead of a clear + // credential error, so fail closed here where the offending credential is + // still known by name. + for (let index = 0; index < value.length; index++) { + const code = apply(stringCharCodeAt, value, [index]) as number; + if (code < 0x20 || code === 0x7f) return undefined; + } return value; } @@ -478,8 +489,16 @@ async function readCredentials( for (let index = 0; index < plan.requiredEnvironmentVariables.length; index++) { const name = plan.requiredEnvironmentVariables[index]!; const value = await readCredential(provider, plan.connectorName, name); - if (value === undefined) append(missing, name); - else values[name] = value; + // RFC 7617 delimits the Basic user-id from the password with the first + // `:`, so a username containing one would silently shift part of itself + // into the password. Fail closed as a missing credential. + if ( + value === undefined || + (plan.kind === "basic" && name === plan.usernameName && + stringIncludesValue(value, ":")) + ) { + append(missing, name); + } else values[name] = value; } if ( plan.kind === "basic" && values[plan.passwordName] === undefined && diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index d423757fb0..44ecf3fdbc 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -12,6 +12,7 @@ import { assertStrictEquals, } from "#veryfront/testing/assert.ts"; import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; +import { deleteEnv, setEnv } from "#veryfront/testing/deno-compat.ts"; import { loadRemoteToolsFromSource } from "#veryfront/tool"; import { executeConfiguredTool } from "#veryfront/agent/runtime/tool-helpers.ts"; import { EXPERIMENTAL_INTEGRATIONS_ENV } from "./feature-flags.ts"; @@ -82,7 +83,7 @@ async function assertConfigurationError( describe("createLocalIntegrationToolSource", () => { afterEach(() => { _resetEnvironmentConfig(); - Deno.env.delete(EXPERIMENTAL_INTEGRATIONS_ENV); + deleteEnv(EXPERIMENTAL_INTEGRATIONS_ENV); }); it("lists only explicitly granted catalog tools with credential-free metadata", async () => { @@ -151,7 +152,7 @@ describe("createLocalIntegrationToolSource", () => { it("does not trust catalog metadata mutated through the public connector API", async () => { _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); - Deno.env.set(EXPERIMENTAL_INTEGRATIONS_ENV, "anthropic"); + setEnv(EXPERIMENTAL_INTEGRATIONS_ENV, "anthropic"); const connector = getConnector("anthropic"); const publicTool = connector?.tools.find((tool) => tool.id === "anthropic__list_workspaces"); assert(publicTool?.endpoint); diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index f1fb0fb71f..3853c00e59 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -263,7 +263,18 @@ function captureLocalCatalog(): Map { return captured; } -const localCatalog = captureLocalCatalog(); +/** + * Captured on first use rather than at module load: the integrations barrel + * statically re-exports this module, so an invalid catalog entry at module + * evaluation would prevent the whole barrel from importing even when no local + * source is ever created. + */ +let localCatalog: Map | undefined; + +function getLocalCatalog(): Map { + localCatalog ??= captureLocalCatalog(); + return localCatalog; +} function assertHttpsCatalogUrl(value: string, label: string): string { let parsed: URL; @@ -436,7 +447,7 @@ function admitTool(canonicalToolId: string): AdmittedLocalIntegrationTool { configurationError(`Local integration tool "${canonicalToolId}" must use a canonical ID`); } - const catalogEntry = mapValue(localCatalog, canonicalToolId); + const catalogEntry = mapValue(getLocalCatalog(), canonicalToolId); if (!catalogEntry) { let knownConnector = false; for (let index = 0; index < connectors.length; index++) { diff --git a/tests/docs/guide-content.test.ts b/tests/docs/guide-content.test.ts index bf444cd477..4547ea6082 100644 --- a/tests/docs/guide-content.test.ts +++ b/tests/docs/guide-content.test.ts @@ -213,7 +213,7 @@ describe("guide content contracts", () => { assertStringIncludes(guide, "## Check capability support"); assertStringIncludes(guide, "Direct provider inference"); assertStringIncludes(guide, "Local agent delegation with `delegates`"); - assertStringIncludes(guide, "Remote integration tools"); + assertStringIncludes(guide, "Integration tools"); assertStringIncludes(guide, "Salesforce service account"); assertStringIncludes(guide, "External Client App"); assertStringIncludes(guide, "createSalesforceServiceAccountToolSource"); diff --git a/tests/docs/guide-contracts.test.ts b/tests/docs/guide-contracts.test.ts index 15013e7091..534e99552e 100644 --- a/tests/docs/guide-contracts.test.ts +++ b/tests/docs/guide-contracts.test.ts @@ -329,7 +329,7 @@ const GUIDE_CONTRACTS: Record = { "ship the whole project directory, not just `dist/`", "Dockerfile", "Check capability support", - "Remote integration tools", + "Integration tools", "createLocalIntegrationToolSource", "loadRemoteToolsFromSource", "Deploy to Kubernetes", From b9cf6b4649762f4feb2ffe0928caba2e51496b0c Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 19:51:21 +0200 Subject: [PATCH 16/25] docs(api-reference): regenerate integrations source line pins --- docs/api-reference/veryfront/integrations.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index 11aa45534e..93844af7e8 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -56,7 +56,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L570) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L581) | | `createSalesforceServiceAccountToolSource` | Create a local Salesforce service-account tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/salesforce-service-account.ts#L675) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L52) | From 9e690a9c3b3a5aa3a938959f5896797f703ae1f0 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Tue, 18 Aug 2026 20:09:35 +0200 Subject: [PATCH 17/25] test(integrations): gate the primordial-poison proof to the Deno runner Removing the direct Deno.env calls made local-tool-source.test.ts newly eligible for the Node and Bun runners. Node's test harness emits diagnostics through Array.prototype.push while the poison window is open across the test's awaits, so the poison crashed the runner itself instead of proving anything about the implementation. The intrinsic-safety proof is runtime-independent and keeps running under Deno; the other fifteen tests in the file now run on Node and Bun, which is what removing the Deno.env exclusion was for. --- src/integrations/local-tool-source.test.ts | 137 +++++++++++---------- 1 file changed, 74 insertions(+), 63 deletions(-) diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 44ecf3fdbc..d63dd851a8 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -13,6 +13,7 @@ import { } from "#veryfront/testing/assert.ts"; import { afterEach, describe, it } from "#veryfront/testing/bdd.ts"; import { deleteEnv, setEnv } from "#veryfront/testing/deno-compat.ts"; +import { isDeno } from "#veryfront/platform/compat/runtime.ts"; import { loadRemoteToolsFromSource } from "#veryfront/tool"; import { executeConfiguredTool } from "#veryfront/agent/runtime/tool-helpers.ts"; import { EXPERIMENTAL_INTEGRATIONS_ENV } from "./feature-flags.ts"; @@ -183,71 +184,81 @@ describe("createLocalIntegrationToolSource", () => { assertEquals(apiKey, TEST_CREDENTIAL); }); - it("retains admission semantics after project code mutates ambient primordials", async () => { - _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); - const restorers: Array<() => void> = []; - let poisonCalls = 0; - const poison = (): never => { - poisonCalls += 1; - throw new Error("ambient primordial used"); - }; - let source: ReturnType | undefined; - let definitions: readonly { name: string }[] | undefined; - - try { - appendRestorer(restorers, replaceProperty(Array, "isArray", () => poison())); - appendRestorer(restorers, replaceProperty(Array.prototype, "map", poison)); - appendRestorer(restorers, replaceProperty(Array.prototype, "push", poison)); - appendRestorer(restorers, replaceProperty(Map.prototype, "get", poison)); - appendRestorer(restorers, replaceProperty(Map.prototype, "has", poison)); - appendRestorer(restorers, replaceProperty(Map.prototype, "set", poison)); - appendRestorer(restorers, replaceProperty(globalThis, "Map", poison)); - appendRestorer(restorers, replaceProperty(Object, "create", poison)); - appendRestorer(restorers, replaceProperty(Object, "defineProperty", poison)); - appendRestorer(restorers, replaceProperty(Object, "entries", poison)); - appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); - appendRestorer(restorers, replaceProperty(Object, "getOwnPropertyDescriptor", poison)); - appendRestorer(restorers, replaceProperty(Object, "values", poison)); - appendRestorer( - restorers, - replaceProperty(Reflect, "getOwnPropertyDescriptor", poison), - ); - appendRestorer(restorers, replaceProperty(Set.prototype, "add", poison)); - appendRestorer(restorers, replaceProperty(Set.prototype, "has", poison)); - appendRestorer(restorers, replaceProperty(globalThis, "Set", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "indexOf", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "lastIndexOf", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "replace", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "replaceAll", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); - appendRestorer(restorers, replaceProperty(String.prototype, "startsWith", poison)); - appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); - appendRestorer( - restorers, - replaceDescriptor(Array.prototype, "0", { - configurable: true, - set: poison, - }), - ); + // Deno-only: Node's test runner emits harness diagnostics through + // Array.prototype.push while the poison window is open across the awaits + // below, so the poison crashes the runner itself rather than proving + // anything about the implementation. The intrinsic-safety proof is + // runtime-independent; every other test in this file still runs on Node + // and Bun. + const denoOnlyIt = isDeno ? it : it.skip; + denoOnlyIt( + "retains admission semantics after project code mutates ambient primordials", + async () => { + _setEnvironmentConfigForTesting({ veryfrontMode: "production", proxyMode: false }); + const restorers: Array<() => void> = []; + let poisonCalls = 0; + const poison = (): never => { + poisonCalls += 1; + throw new Error("ambient primordial used"); + }; + let source: ReturnType | undefined; + let definitions: readonly { name: string }[] | undefined; + + try { + appendRestorer(restorers, replaceProperty(Array, "isArray", () => poison())); + appendRestorer(restorers, replaceProperty(Array.prototype, "map", poison)); + appendRestorer(restorers, replaceProperty(Array.prototype, "push", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "get", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "has", poison)); + appendRestorer(restorers, replaceProperty(Map.prototype, "set", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "Map", poison)); + appendRestorer(restorers, replaceProperty(Object, "create", poison)); + appendRestorer(restorers, replaceProperty(Object, "defineProperty", poison)); + appendRestorer(restorers, replaceProperty(Object, "entries", poison)); + appendRestorer(restorers, replaceProperty(Object, "freeze", poison)); + appendRestorer(restorers, replaceProperty(Object, "getOwnPropertyDescriptor", poison)); + appendRestorer(restorers, replaceProperty(Object, "values", poison)); + appendRestorer( + restorers, + replaceProperty(Reflect, "getOwnPropertyDescriptor", poison), + ); + appendRestorer(restorers, replaceProperty(Set.prototype, "add", poison)); + appendRestorer(restorers, replaceProperty(Set.prototype, "has", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "Set", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "charCodeAt", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "includes", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "indexOf", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "lastIndexOf", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "replace", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "replaceAll", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "slice", poison)); + appendRestorer(restorers, replaceProperty(String.prototype, "startsWith", poison)); + appendRestorer(restorers, replaceProperty(globalThis, "URL", poison)); + appendRestorer( + restorers, + replaceDescriptor(Array.prototype, "0", { + configurable: true, + set: poison, + }), + ); - source = createLocalIntegrationToolSource({ - tools: ["vercel__list_projects"], - credentialProvider: testCredentialProvider, - }); - definitions = await source.listTools(); - } finally { - for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); - } + source = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + definitions = await source.listTools(); + } finally { + for (let index = restorers.length - 1; index >= 0; index--) restorers[index]?.(); + } - assertEquals(poisonCalls, 0); - assert(source); - assert(Object.isFrozen(source)); - assertEquals(definitions?.map((definition) => definition.name), [ - "vercel__list_projects", - ]); - }); + assertEquals(poisonCalls, 0); + assert(source); + assert(Object.isFrozen(source)); + assertEquals(definitions?.map((definition) => definition.name), [ + "vercel__list_projects", + ]); + }, + ); it("validates configured credential names before exposing tools", async () => { const calls: string[] = []; From c26c7254a53c2b75ebf78c6602679941fa748f7a Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 02:23:16 +0200 Subject: [PATCH 18/25] fix(integrations): pin a granted endpoint path against dot-segment arguments MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `encodeURIComponent` escapes `/` but leaves `.` alone, so a path argument of `.` or `..` survived into the endpoint template as a relative segment that the `URL` constructor then resolved away. A grant for `GET /repos/{owner}/{repo}/issues` called with both arguments set to `..` built `https://api.example.test/repos/../../issues`, which normalizes to `https://api.example.test/issues` — a different route on the same host, called with the tool's method and the project's credential headers. The admitted-origin check could not see it: normalization never changes the origin, so the comparison passed. Nothing else pinned the path, so the grant no longer named the endpoint it admitted. Path arguments are now rejected when they encode to an empty segment or to a dot segment. A value that merely contains dots (`...`, `a.b`) or that arrives pre-encoded (`%2e%2e` -> `%252e%252e`) is unaffected, because neither is a relative segment. Refs veryfront/veryfront-issue-inbox#495 --- .../local-endpoint-executor.test.ts | 88 +++++++++++++++++++ src/integrations/local-endpoint-executor.ts | 23 +++-- 2 files changed, 106 insertions(+), 5 deletions(-) diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index 9b4ee42ed6..b6255e0a1a 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -450,6 +450,94 @@ describe("local integration endpoint executor", () => { } }); + it("rejects a path argument that is a dot segment", async () => { + const attempts: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + attempts.push(request.url.href); + return Promise.resolve(Response.json({})); + }; + + for (const traversal of ["..", ".", ""]) { + const error = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/repos/{owner}/{repo}/issues", + params: { + owner: { type: "string", in: "path", description: "Owner", required: true }, + repo: { type: "string", in: "path", description: "Repo", required: true }, + }, + }), + args: { owner: traversal, repo: traversal }, + authHeaders: { Authorization: `Bearer ${SECRET}` }, + allowedOrigin: "https://api.example.test", + transport, + }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + assertEquals(error.message.includes(SECRET), false); + } + + assertEquals(attempts, []); + }); + + it("keeps a granted endpoint path pinned when a path argument only contains dots", async () => { + const requests: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + requests.push(request.url.href); + return Promise.resolve(Response.json({})); + }; + + await executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/repos/{owner}/{repo}/issues", + params: { + owner: { type: "string", in: "path", description: "Owner", required: true }, + repo: { type: "string", in: "path", description: "Repo", required: true }, + }, + }), + args: { owner: "...", repo: "%2e%2e" }, + authHeaders: {}, + allowedOrigin: "https://api.example.test", + transport, + }); + + assertEquals(requests, ["https://api.example.test/repos/.../%252e%252e/issues"]); + }); + + it("rejects an endpoint whose built URL leaves the admitted origin", async () => { + const attempts: string[] = []; + const transport: LocalIntegrationEndpointTransport = (request) => { + attempts.push(request.url.href); + return Promise.resolve(Response.json({})); + }; + + const error = await assertRejects( + () => + executeLocalIntegrationEndpoint({ + endpoint: endpoint({ + method: "GET", + url: "https://api.example.test/items", + }), + args: {}, + authHeaders: { Authorization: `Bearer ${SECRET}` }, + allowedOrigin: "https://other.example.test", + transport, + }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + assertEquals(error.message.includes(SECRET), false); + assertEquals(attempts, []); + }); + it("cancels a response rejected by its declared size", async () => { const response = new Response("{}", { headers: { "content-length": String(4 * 1024 * 1024 + 1) }, diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index e0de5d5651..5cb99e5b94 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -276,6 +276,23 @@ function scalarString(value: unknown): string { requestInvalid("Local integration path, query, and header arguments must be scalar values"); } +/** + * Encodes a path argument as a single URL path segment. + * + * `encodeURIComponent` escapes `/` but leaves `.` alone, so a value of `.` or + * `..` survives into the template as a relative segment that `new URL` then + * resolves away: `/repos/{owner}/{repo}/issues` with both arguments set to `..` + * collapses to `/issues`. The origin never changes, so the admitted-origin check + * cannot see it, and the grant would no longer pin the endpoint it named. + */ +function pathSegment(value: unknown): string { + const encoded = encodeUriComponent(scalarString(value)); + if (encoded === "" || encoded === "." || encoded === "..") { + requestInvalid("Local integration path arguments must name a single path segment"); + } + return encoded; +} + function appendQueryValue( searchParams: URLSearchParams, name: string, @@ -388,11 +405,7 @@ function buildRequest( const resolved = fieldValue(args, name, field); if (!resolved.present) continue; if (field.in === "path") { - endpointUrl = replaceAll( - endpointUrl, - `{${name}}`, - encodeUriComponent(scalarString(resolved.value)), - ); + endpointUrl = replaceAll(endpointUrl, `{${name}}`, pathSegment(resolved.value)); } else if (field.in === "header") { setHeader(headers, field.headerName ?? name, scalarString(resolved.value)); } From a12cbe647da1100a95b0f4f6f58e4f7bc31913b2 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 02:42:47 +0200 Subject: [PATCH 19/25] fix(integrations): sanitize the tool name in local integration config errors `safeIdentifier` bounds and charset-restricts caller identifiers, but only the request-failed and response-invalid paths used it. `executeTool` interpolated a raw, caller-supplied tool name into the not-granted configuration error, and tool names arrive from the model. An unbounded value carrying newlines or control characters therefore landed verbatim in error metadata that is logged upstream. Nothing secret can reach this path, so this closes a hygiene inconsistency rather than a leak, but the guard already existed one module away and the config path is the one an untrusted name actually reaches. The helper is now exported as `safeLocalIntegrationIdentifier` and applied at that call site, so an unrecognized name collapses to "unknown" rather than being escaped. Refs veryfront/veryfront-issue-inbox#495 --- src/integrations/local-integration-errors.ts | 12 ++++++++++++ src/integrations/local-tool-source.test.ts | 19 +++++++++++++++++++ src/integrations/local-tool-source.ts | 11 +++++++++-- templates/manifest.generated.ts | 2 +- 4 files changed, 41 insertions(+), 3 deletions(-) diff --git a/src/integrations/local-integration-errors.ts b/src/integrations/local-integration-errors.ts index 6bf4173fe1..efc7452ae3 100644 --- a/src/integrations/local-integration-errors.ts +++ b/src/integrations/local-integration-errors.ts @@ -21,6 +21,18 @@ export interface LocalIntegrationDiagnosticIdentity { readonly toolId: string; } +/** + * Reduces a caller-supplied identifier to a bounded, log-safe form. + * + * Tool names reach this module from the model, so an unbounded value carrying + * newlines or control characters must not land verbatim in error metadata that + * is logged upstream. Anything outside the identifier charset collapses to + * `"unknown"` rather than being escaped, so no caller string survives. + */ +export function safeLocalIntegrationIdentifier(value: unknown): string { + return safeIdentifier(value); +} + function safeIdentifier(value: unknown): string { if (typeof value !== "string" || value.length === 0 || value.length > 200) return "unknown"; for (let index = 0; index < value.length; index++) { diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index d63dd851a8..1a9d1eb478 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -339,6 +339,25 @@ describe("createLocalIntegrationToolSource", () => { ); }); + it("keeps an ungranted tool name out of the error verbatim", async () => { + const source = createLocalIntegrationToolSource({ + tools: ["vercel__list_projects"], + credentialProvider: testCredentialProvider, + }); + + const hostile = `vercel__evil\n${"x".repeat(400)}`; + const error = await assertRejects( + () => source.executeTool(hostile, {}), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-config-invalid"); + assertEquals(error.message.includes(hostile), false); + assertEquals(error.message.includes("\n"), false); + assert(error.message.includes("unknown"), error.message); + }); + it("executes admitted API-key and Basic tools with project-owned credentials", async () => { const directRequests: string[] = []; const transport: LocalIntegrationEndpointTransport = (request) => { diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 3853c00e59..7708e62f3d 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -19,7 +19,10 @@ import { type LocalIntegrationEndpointTransport, snapshotLocalIntegrationEndpointArguments, } from "#veryfront/integrations/local-endpoint-executor.ts"; -import { localIntegrationConfigurationError } from "#veryfront/integrations/local-integration-errors.ts"; +import { + localIntegrationConfigurationError, + safeLocalIntegrationIdentifier, +} from "#veryfront/integrations/local-integration-errors.ts"; import { MAX_LOCAL_INTEGRATION_TOOLS } from "#veryfront/integrations/limits.ts"; import { parseIntegrationToolIdentity } from "#veryfront/integrations/source-policy.ts"; import type { IntegrationConfig, IntegrationToolMeta } from "#veryfront/integrations/schema.ts"; @@ -536,7 +539,11 @@ function createLocalIntegrationToolSourceInternal( throwIfCallerAborted(context?.abortSignal); const tool = mapValue(admitted, toolName); if (!tool) { - configurationError(`Local integration tool "${toolName}" is not granted by this source`); + configurationError( + `Local integration tool "${ + safeLocalIntegrationIdentifier(toolName) + }" is not granted by this source`, + ); } const validatedArgs = snapshotLocalIntegrationEndpointArguments(tool.endpoint, args); const auth = await mintLocalCredentialAuth( diff --git a/templates/manifest.generated.ts b/templates/manifest.generated.ts index 52d0ef5b8b..ad47bd061c 100644 --- a/templates/manifest.generated.ts +++ b/templates/manifest.generated.ts @@ -1,3 +1,3 @@ /** Generated by scripts/build/generate-templates-manifest.ts. */ export const COMPRESSED_TEMPLATE_MANIFEST_BASE64: string = - "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"; + "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"; From 2e36c60ddfa6d7d6664ff0ceaeb601eef4e67932 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 02:58:25 +0200 Subject: [PATCH 20/25] docs(api-reference): refresh integrations source line pins Regenerated with `deno task docs` on the CI-pinned Deno 2.7.7. The sanitization commit shifted three declarations in `local-tool-source.ts`; only the line pins move and no documented symbol changes. Refs veryfront/veryfront-issue-inbox#495 --- docs/api-reference/veryfront/integrations.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index 93844af7e8..a456b686dd 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -56,7 +56,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L581) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L588) | | `createSalesforceServiceAccountToolSource` | Create a local Salesforce service-account tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/salesforce-service-account.ts#L675) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L52) | @@ -79,8 +79,8 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | `IntegrationPrompt` | Public API contract for integration prompt. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L497) | | `IntegrationTool` | Public API contract for integration tool. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/types.ts#L68) | | `IntegrationToolMeta` | Public API contract for integration tool meta. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L491) | -| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L55) | -| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L60) | +| `LocalIntegrationCredentialProvider` | Resolve one local integration credential by its canonical environment-variable name. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L58) | +| `LocalIntegrationToolSourceOptions` | Options for a catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L63) | | `OAuthConfig` | Configuration used by oauth. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L489) | | `OAuthField` | Public API contract for oauth field. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/schema.ts#L487) | | `RemoteIntegrationToolDiscoveryResult` | Result of listing the integration tools available to the current run. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L86) | From 60303e205760c1eb4d45eb19cf4001ef85adc9f3 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 03:03:46 +0200 Subject: [PATCH 21/25] fix(integrations): reject dot-segment path arguments before minting credentials The dot-segment guard ran only in `buildRequest`, which `executeTool` reaches after `mintLocalCredentialAuth`. For a client-credentials tool such as `paypal__get_invoice`, an invalid `{ invoiceId: ".." }` therefore completed an OAuth token round trip -- sending the client credentials to the token endpoint -- before anything rejected it. The pre-auth argument snapshot only coerced path values with `scalarString`, so it let the value through. `snapshotLocalIntegrationEndpointArguments` now validates path arguments with the same `pathSegment` helper the builder uses, so the rejection happens before any credential is resolved or minted and before any transport call. Header arguments keep their `scalarString` coercion; only path values carry path-segment semantics. The build-time guard stays. The two are deliberately redundant: the executor is exported and callable directly, so it cannot rely on a caller having snapshotted first. Reported by Codex review on this PR. Refs veryfront/veryfront-issue-inbox#495 --- src/integrations/local-endpoint-executor.ts | 10 ++++--- src/integrations/local-tool-source.test.ts | 30 +++++++++++++++++++++ 2 files changed, 37 insertions(+), 3 deletions(-) diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 5cb99e5b94..16ab5eba6e 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -362,9 +362,13 @@ export function snapshotLocalIntegrationEndpointArguments( const field = endpoint.params?.[name]; if (!field) continue; const resolved = fieldValue(snapshot, name, field); - if (resolved.present && (field.in === "path" || field.in === "header")) { - scalarString(resolved.value); - } + if (!resolved.present) continue; + // Path arguments are validated here, not only where the URL is built: + // `executeTool` mints credentials between this snapshot and `buildRequest`, + // so a rejection that waits for build time would already have sent the + // client credentials to the token endpoint. + if (field.in === "path") pathSegment(resolved.value); + else if (field.in === "header") scalarString(resolved.value); } const bodyNames = objectKeys(endpoint.body ?? {}); diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 1a9d1eb478..26dc53f6fe 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -467,6 +467,36 @@ describe("createLocalIntegrationToolSource", () => { assertEquals(transportCalls, 0); }); + it("rejects a dot-segment path argument before minting credentials", async () => { + for (const traversal of ["..", ".", ""]) { + let credentialProviderCalls = 0; + let transportCalls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["paypal__get_invoice"], + credentialProvider: () => { + credentialProviderCalls += 1; + return TEST_CREDENTIAL; + }, + }, + () => { + transportCalls += 1; + return Promise.resolve(Response.json({ access_token: TEST_CREDENTIAL })); + }, + ); + + const error = await assertRejects( + () => source.executeTool("paypal__get_invoice", { invoiceId: traversal }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + assertEquals(credentialProviderCalls, 0); + assertEquals(transportCalls, 0); + } + }); + it("rejects pre-aborted execution before resolving credentials", async () => { let credentialProviderCalls = 0; let transportCalls = 0; From 76ee7311738fdb5c59fa40ec2b4b38995bba65ef Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 03:08:55 +0200 Subject: [PATCH 22/25] fix(integrations): validate header arguments before minting credentials The same ordering defect the path guard just fixed also applied to header arguments. The pre-auth snapshot only coerced them with `scalarString`, while the rejection for a value the `Headers` setter refuses happened in `buildRequest` -- after `mintLocalCredentialAuth`. `mongodb-atlas__list_projects` is client-credentials and takes an `accept` header argument, so a value containing CRLF completed an OAuth token round trip before anything rejected it. 87 catalog tools expose a header argument on an OAuth connector, 4 of them on a client-credentials one. The snapshot now runs the argument through the same `setHeader` helper against a throwaway `Headers`, so the header name and value are validated by exactly the code that will later set them, with no second copy of the rules. The invariant this settles on: every argument class is fully validated before any credential is resolved or minted. Refs veryfront/veryfront-issue-inbox#495 --- src/integrations/local-endpoint-executor.ts | 16 ++++++++---- src/integrations/local-tool-source.test.ts | 29 +++++++++++++++++++++ 2 files changed, 40 insertions(+), 5 deletions(-) diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 16ab5eba6e..61997a7f95 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -363,12 +363,18 @@ export function snapshotLocalIntegrationEndpointArguments( if (!field) continue; const resolved = fieldValue(snapshot, name, field); if (!resolved.present) continue; - // Path arguments are validated here, not only where the URL is built: - // `executeTool` mints credentials between this snapshot and `buildRequest`, - // so a rejection that waits for build time would already have sent the - // client credentials to the token endpoint. + // Path and header arguments are fully validated here, not only where the + // request is built: `executeTool` mints credentials between this snapshot + // and `buildRequest`, so a rejection that waits for build time would + // already have sent the client credentials to the token endpoint. if (field.in === "path") pathSegment(resolved.value); - else if (field.in === "header") scalarString(resolved.value); + else if (field.in === "header") { + setHeader( + new HeadersConstructor(), + field.headerName ?? name, + scalarString(resolved.value), + ); + } } const bodyNames = objectKeys(endpoint.body ?? {}); diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index 26dc53f6fe..d18686b68a 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -497,6 +497,35 @@ describe("createLocalIntegrationToolSource", () => { } }); + it("rejects an invalid header argument before minting credentials", async () => { + let credentialProviderCalls = 0; + let transportCalls = 0; + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["mongodb-atlas__list_projects"], + credentialProvider: () => { + credentialProviderCalls += 1; + return TEST_CREDENTIAL; + }, + }, + () => { + transportCalls += 1; + return Promise.resolve(Response.json({ access_token: TEST_CREDENTIAL })); + }, + ); + + const error = await assertRejects( + () => + source.executeTool("mongodb-atlas__list_projects", { accept: "application/json\r\nx: y" }), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + assertEquals(credentialProviderCalls, 0); + assertEquals(transportCalls, 0); + }); + it("rejects pre-aborted execution before resolving credentials", async () => { let credentialProviderCalls = 0; let transportCalls = 0; From 85cad0e25c98ffa9d79f00aafbf7969ccb53f4c8 Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 03:27:38 +0200 Subject: [PATCH 23/25] fix(integrations): bound-check the assembled body before minting credentials Validating each body field on its own proves nothing about the size of the body they add up to, because an omitted field still contributes its catalog default. Supplied arguments could therefore pass the pre-auth snapshot while the body built from them exceeded the 4 MiB JSON bound, leaving `serializeJson` in `buildRequest` to reject it -- after `mintLocalCredentialAuth`. `salesforce__create_case` is the reachable case: four supplied strings just under the 1 MiB per-string cap serialize to under the limit, and the `Status` and `Origin` defaults carry the assembled body over it. The credential provider and the token endpoint were both invoked before the rejection. The body assembly is extracted as `assembleBody` and called from both the snapshot and `buildRequest`, so the bound is checked against the body that will actually be sent rather than against a reconstruction that could drift from it. Reported by Codex review on this PR. Refs veryfront/veryfront-issue-inbox#495 --- .../local-endpoint-executor.test.ts | 41 ++++++++++ src/integrations/local-endpoint-executor.ts | 82 +++++++++++-------- 2 files changed, 90 insertions(+), 33 deletions(-) diff --git a/src/integrations/local-endpoint-executor.test.ts b/src/integrations/local-endpoint-executor.test.ts index b6255e0a1a..187e6da218 100644 --- a/src/integrations/local-endpoint-executor.test.ts +++ b/src/integrations/local-endpoint-executor.test.ts @@ -6,6 +6,7 @@ import { assertInstanceOf, assertRejects, assertStrictEquals, + assertThrows, } from "#veryfront/testing/assert.ts"; import { describe, it } from "#veryfront/testing/bdd.ts"; import type { IntegrationToolMeta } from "./schema.ts"; @@ -14,6 +15,7 @@ import { type ExecuteLocalIntegrationEndpointOptions, type LocalIntegrationEndpointTransport, type LocalIntegrationEndpointTransportRequest, + snapshotLocalIntegrationEndpointArguments, } from "./local-endpoint-executor.ts"; type IntegrationEndpoint = NonNullable; @@ -538,6 +540,45 @@ describe("local integration endpoint executor", () => { assertEquals(attempts, []); }); + it("rejects an assembled body that only exceeds the JSON bound once defaults apply", () => { + // A body field left unsupplied still contributes its catalog default to the + // assembled request. Validating each field on its own therefore proves + // nothing about the size of the body they add up to. + const bodyEndpoint = endpoint({ + method: "POST", + url: "https://api.example.test/v1/records", + body: { + a: { type: "string", description: "A", required: true }, + b: { type: "string", description: "B", required: true }, + c: { type: "string", description: "C", required: true }, + d: { type: "string", description: "D", required: true }, + padded: { type: "string", description: "Padded", default: "default-value" }, + }, + }); + + const maxSerializedBytes = 4 * 1024 * 1024; + // Four strings just under the 1 MiB per-string cap, sized so the supplied + // arguments land a few bytes under the 4 MiB serialized cap and the single + // defaulted field is what carries them over it. + const chunk = "x".repeat(1024 * 1024 - 8); + const supplied = { a: chunk, b: chunk, c: chunk, d: chunk }; + const suppliedBytes = new TextEncoder().encode(JSON.stringify(supplied)).length; + const assembled = { ...supplied, padded: "default-value" }; + const assembledBytes = new TextEncoder().encode(JSON.stringify(assembled)).length; + + // The premise: supplied arguments fit, the assembled body does not. + assert(suppliedBytes <= maxSerializedBytes, `supplied ${suppliedBytes}`); + assert(assembledBytes > maxSerializedBytes, `assembled ${assembledBytes}`); + + const error = assertThrows( + () => snapshotLocalIntegrationEndpointArguments(bodyEndpoint, supplied), + VeryfrontError, + ); + + assertInstanceOf(error, VeryfrontError); + assertEquals(error.slug, "local-integration-request-invalid"); + }); + it("cancels a response rejected by its declared size", async () => { const response = new Response("{}", { headers: { "content-length": String(4 * 1024 * 1024 + 1) }, diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 61997a7f95..f2c685274c 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -377,12 +377,12 @@ export function snapshotLocalIntegrationEndpointArguments( } } - const bodyNames = objectKeys(endpoint.body ?? {}); - for (let index = 0; index < bodyNames.length; index++) { - const name = bodyNames[index]!; - const field = endpoint.body?.[name]; - if (field) fieldValue(snapshot, name, field); - } + // Assembled rather than checked field by field: an omitted field still + // contributes its catalog default, so fields that each fit can still add up + // to a body over the JSON bound. The result is discarded and `buildRequest` + // rebuilds it from the same helper; the point here is to reject before + // anything is minted. + assembleBody(endpoint, snapshot); return snapshot; } @@ -396,6 +396,48 @@ function serializeJson(value: unknown): string { } } +/** + * Serializes the request body an endpoint would send for these arguments. + * + * Assembling it is the only way to bound-check it: an omitted field still + * contributes its catalog default, so fields that individually fit can still + * add up to a body over the JSON limit. Shared with the pre-auth snapshot so + * that oversize body is rejected before any credential is minted, rather than + * at request-construction time. + */ +function assembleBody( + endpoint: IntegrationEndpoint, + args: Record, +): string | undefined { + const bodyFields = objectKeys(endpoint.body ?? {}); + if (endpoint.bodyMode === "passthrough") { + if (bodyFields.length !== 1) { + requestInvalid("Local integration passthrough bodies require exactly one field"); + } + const name = bodyFields[0]!; + const field = endpoint.body?.[name]!; + const resolved = fieldValue(args, name, field); + return resolved.present ? serializeJson(resolved.value) : undefined; + } + if (bodyFields.length === 0) return undefined; + + const record = objectCreate(null) as Record; + for (let index = 0; index < bodyFields.length; index++) { + const name = bodyFields[index]!; + const field = endpoint.body?.[name]!; + const resolved = fieldValue(args, name, field); + if (resolved.present) { + objectDefineProperty(record, name, { + configurable: true, + enumerable: true, + value: resolved.value, + writable: true, + }); + } + } + return serializeJson(record); +} + function buildRequest( endpoint: IntegrationEndpoint, args: Record, @@ -455,33 +497,7 @@ function buildRequest( setHeader(headers, name, value.value); } - let body: string | undefined; - const bodyFields = objectKeys(endpoint.body ?? {}); - if (endpoint.bodyMode === "passthrough") { - if (bodyFields.length !== 1) { - requestInvalid("Local integration passthrough bodies require exactly one field"); - } - const name = bodyFields[0]!; - const field = endpoint.body?.[name]!; - const resolved = fieldValue(args, name, field); - if (resolved.present) body = serializeJson(resolved.value); - } else if (bodyFields.length > 0) { - const record = objectCreate(null) as Record; - for (let index = 0; index < bodyFields.length; index++) { - const name = bodyFields[index]!; - const field = endpoint.body?.[name]!; - const resolved = fieldValue(args, name, field); - if (resolved.present) { - objectDefineProperty(record, name, { - configurable: true, - enumerable: true, - value: resolved.value, - writable: true, - }); - } - } - body = serializeJson(record); - } + const body = assembleBody(endpoint, args); if (body !== undefined) { setHeader(headers, "Content-Type", endpoint.contentType ?? "application/json"); From da9654cf6e03838f63415e7d0f24bcbe01ec1e1b Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 03:58:23 +0200 Subject: [PATCH 24/25] fix(integrations): send the body that was bound-checked before minting Sharing `assembleBody` between the pre-auth snapshot and `buildRequest` made both calls run the same code, but not in the same environment. Caller-supplied credential code runs between them, and it can install an `Object.prototype.toJSON`. `JSON.stringify` honours an inherited `toJSON` for the ordinary nested objects a snapshot contains -- a null-prototype outer record does not help -- so the second assembly could produce a completely different body from the one that was bounded. Measured, not theorised: with a provider that poisons the prototype while resolving the credential, a `brevo__create_contact` call sent the literal body `"POISONED"` in place of the contact payload. The bound check is bypassed entirely, and the value sent to the provider under the project's credential is whatever that code chooses. `snapshotLocalIntegrationEndpointArguments` now returns the serialized body alongside the arguments, and `executeTool` threads it into the executor, which sends it verbatim. Direct executor callers still assemble locally: they have no credential step for the environment to change across. Reported by Codex review on this PR. Refs veryfront/veryfront-issue-inbox#495 --- docs/api-reference/veryfront/integrations.md | 2 +- src/integrations/local-endpoint-executor.ts | 38 ++++++++++++--- src/integrations/local-tool-source.test.ts | 51 ++++++++++++++++++++ src/integrations/local-tool-source.ts | 7 ++- 4 files changed, 87 insertions(+), 11 deletions(-) diff --git a/docs/api-reference/veryfront/integrations.md b/docs/api-reference/veryfront/integrations.md index a456b686dd..01bebe0c01 100644 --- a/docs/api-reference/veryfront/integrations.md +++ b/docs/api-reference/veryfront/integrations.md @@ -56,7 +56,7 @@ const runtimeTools = await getRemoteIntegrationToolDefinitions(); | Name | Description | Source | | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L588) | +| `createLocalIntegrationToolSource` | Create an explicitly granted, catalog-backed local integration tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/local-tool-source.ts#L591) | | `createSalesforceServiceAccountToolSource` | Create a local Salesforce service-account tool source. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/salesforce-service-account.ts#L675) | | `executeRemoteIntegrationTool` | Execute a remote integration tool via the API. Called by the agent runtime when a tool isn't found in the local registry. The request, response, and caller-supplied cancellation signal remain bounded for the complete network and response-body lifecycle. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/remote-tools.ts#L829) | | `getConnector` | Return connector. | [source](https://github.com/veryfront/veryfront-code/blob/main/src/integrations/index.ts#L52) | diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index f2c685274c..45bc8a8d42 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -110,6 +110,14 @@ export interface ExecuteLocalIntegrationEndpointOptions extends LocalIntegration readonly authHeaders: Readonly>; readonly allowedOrigin: string; readonly signal?: AbortSignal; + /** + * Body serialized by {@link snapshotLocalIntegrationEndpointArguments} before + * any credential was resolved. Supply it whenever the arguments were + * snapshotted: re-serializing here would run after caller-supplied credential + * code, which can change what `JSON.stringify` produces, so the body sent + * would not be the body that was checked. + */ + readonly body?: string | undefined; /** Internal test seam. Production callers use the standard integration deadline. */ readonly timeoutMs?: number; /** Internal test seam. Production callers use the guarded egress transport. */ @@ -352,7 +360,7 @@ function assertKnownArguments( export function snapshotLocalIntegrationEndpointArguments( endpoint: IntegrationEndpoint, args: Record, -): Record { +): { args: Record; body: string | undefined } { const snapshot = snapshotArguments(args); assertKnownArguments(snapshot, endpoint); @@ -379,11 +387,16 @@ export function snapshotLocalIntegrationEndpointArguments( // Assembled rather than checked field by field: an omitted field still // contributes its catalog default, so fields that each fit can still add up - // to a body over the JSON bound. The result is discarded and `buildRequest` - // rebuilds it from the same helper; the point here is to reject before - // anything is minted. - assembleBody(endpoint, snapshot); - return snapshot; + // to a body over the JSON bound. + // + // The serialized result is returned, not discarded, because re-serializing it + // in `buildRequest` would happen after caller-supplied credential code has + // run. That code can install an `Object.prototype.toJSON`, which + // `JSON.stringify` honours for the ordinary nested objects a snapshot + // contains, so a second assembly can produce a body that was never bounded + // or checked. + const body = assembleBody(endpoint, snapshot); + return { args: snapshot, body }; } function serializeJson(value: unknown): string { @@ -444,6 +457,7 @@ function buildRequest( authHeaders: Readonly>, allowedOrigin: string, signal: AbortSignal, + preSerializedBody?: string | undefined, ): LocalIntegrationEndpointTransportRequest { assertKnownArguments(args, endpoint); let endpointUrl = endpoint.url; @@ -497,7 +511,9 @@ function buildRequest( setHeader(headers, name, value.value); } - const body = assembleBody(endpoint, args); + // Only assemble here when no pre-auth body was threaded in; see + // `ExecuteLocalIntegrationEndpointOptions.body`. + const body = preSerializedBody ?? assembleBody(endpoint, args); if (body !== undefined) { setHeader(headers, "Content-Type", endpoint.contentType ?? "application/json"); @@ -680,7 +696,12 @@ export async function executeLocalIntegrationEndpoint( options: ExecuteLocalIntegrationEndpointOptions, ): Promise { throwIfCallerAborted(options.signal); - const args = snapshotLocalIntegrationEndpointArguments(options.endpoint, options.args); + // A caller that already snapshotted supplies its own pre-auth body; this + // local snapshot covers direct callers, which have no credential step to + // straddle. + const snapshot = snapshotLocalIntegrationEndpointArguments(options.endpoint, options.args); + const args = snapshot.args; + const body = options.body ?? snapshot.body; const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, @@ -693,6 +714,7 @@ export async function executeLocalIntegrationEndpoint( options.authHeaders, options.allowedOrigin, signalLease.signal, + body, ); const result = await executeTransportRequest( request, diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index d18686b68a..a57ea072c8 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -526,6 +526,57 @@ describe("createLocalIntegrationToolSource", () => { assertEquals(transportCalls, 0); }); + // Deno-only for the same reason as the primordial-poisoning proof above: the + // poison window spans an await, and Node's runner serializes its own + // diagnostics through the mutated prototype. + const bodyDriftIt = isDeno ? it : it.skip; + bodyDriftIt("sends the body it bound-checked, not one re-serialized after minting", async () => { + let sentBody: BodyInit | null | undefined; + let restored = false; + const restore = (): void => { + if (restored) return; + restored = true; + deleteProperty(Object.prototype, "toJSON"); + }; + + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["brevo__create_contact"], + credentialProvider: () => { + // Caller-supplied code runs between the pre-auth snapshot and request + // construction. Re-serializing after this point would send a body + // nothing ever checked. + defineProperty(Object.prototype, "toJSON", { + configurable: true, + value: () => "POISONED", + writable: true, + }); + return TEST_CREDENTIAL; + }, + }, + (request) => { + sentBody = request.init.body; + restore(); + return Promise.resolve(Response.json({ contact: { id: "1" } })); + }, + ); + + try { + await source.executeTool("brevo__create_contact", { + email: "ada@example.test", + attributes: { FIRSTNAME: "Ada" }, + }); + } finally { + restore(); + } + + // Includes the catalog default, i.e. the assembled body that was bounded. + assertEquals( + sentBody, + '{"email":"ada@example.test","attributes":{"FIRSTNAME":"Ada"},"updateEnabled":false}', + ); + }); + it("rejects pre-aborted execution before resolving credentials", async () => { let credentialProviderCalls = 0; let transportCalls = 0; diff --git a/src/integrations/local-tool-source.ts b/src/integrations/local-tool-source.ts index 7708e62f3d..41a84194a3 100644 --- a/src/integrations/local-tool-source.ts +++ b/src/integrations/local-tool-source.ts @@ -545,7 +545,7 @@ function createLocalIntegrationToolSourceInternal( }" is not granted by this source`, ); } - const validatedArgs = snapshotLocalIntegrationEndpointArguments(tool.endpoint, args); + const validated = snapshotLocalIntegrationEndpointArguments(tool.endpoint, args); const auth = await mintLocalCredentialAuth( await resolveLocalCredentialAuth(tool.authPlan, credentialProvider), toolName, @@ -574,7 +574,10 @@ function createLocalIntegrationToolSourceInternal( connectorName: tool.connector.name, toolId: toolName, endpoint, - args: validatedArgs, + args: validated.args, + // Serialized before the credential step below; re-serializing after it + // could send a body that was never bound-checked. + body: validated.body, authHeaders: auth.headers, allowedOrigin, signal: context?.abortSignal, From 54c379ffba5ac87d9c19eeebc4dfc13324fdcabd Mon Sep 17 00:00:00 2001 From: Koji Wakayama Date: Wed, 19 Aug 2026 04:14:51 +0200 Subject: [PATCH 25/25] fix(integrations): skip re-serializing a body the caller already assembled Threading the pre-auth body stopped the executor from *sending* a re-serialized body, but it still *performed* the second assembly and discarded the result. That is invisible when a poisoned `toJSON` returns a value and fatal when it throws: any endpoint with a nested or passthrough body still failed after the credential had been resolved. Argument validation is split from body serialization. `snapshotAndValidateArguments` does the argument work alone, and the public snapshot is that plus one assembly. The executor validates arguments, then assembles only when no pre-auth body was threaded in, so a caller that already serialized never serializes twice. The previous test could not see this, because its `toJSON` returned a string rather than throwing, so the redundant assembly succeeded and its result was dropped. The new test throws instead. Reported by Codex review on this PR. Refs veryfront/veryfront-issue-inbox#495 --- src/integrations/local-endpoint-executor.ts | 49 +++++++++++++-------- src/integrations/local-tool-source.test.ts | 47 ++++++++++++++++++++ 2 files changed, 78 insertions(+), 18 deletions(-) diff --git a/src/integrations/local-endpoint-executor.ts b/src/integrations/local-endpoint-executor.ts index 45bc8a8d42..389dcd7607 100644 --- a/src/integrations/local-endpoint-executor.ts +++ b/src/integrations/local-endpoint-executor.ts @@ -361,6 +361,31 @@ export function snapshotLocalIntegrationEndpointArguments( endpoint: IntegrationEndpoint, args: Record, ): { args: Record; body: string | undefined } { + const snapshot = snapshotAndValidateArguments(endpoint, args); + // Assembled rather than checked field by field: an omitted field still + // contributes its catalog default, so fields that each fit can still add up + // to a body over the JSON bound. + // + // The serialized result is returned, not discarded, because re-serializing it + // later would happen after caller-supplied credential code has run. That code + // can install an `Object.prototype.toJSON`, which `JSON.stringify` honours for + // the ordinary nested objects a snapshot contains, so a second assembly can + // produce a body that was never bounded -- or throw outright. + const body = assembleBody(endpoint, snapshot); + return { args: snapshot, body }; +} + +/** + * Validates arguments without touching the body. + * + * Split out so a caller that already holds a pre-auth body never triggers a + * second serialization: that assembly runs after credential resolution, where a + * poisoned `toJSON` can make it throw even though the threaded body is sound. + */ +function snapshotAndValidateArguments( + endpoint: IntegrationEndpoint, + args: Record, +): Record { const snapshot = snapshotArguments(args); assertKnownArguments(snapshot, endpoint); @@ -385,18 +410,7 @@ export function snapshotLocalIntegrationEndpointArguments( } } - // Assembled rather than checked field by field: an omitted field still - // contributes its catalog default, so fields that each fit can still add up - // to a body over the JSON bound. - // - // The serialized result is returned, not discarded, because re-serializing it - // in `buildRequest` would happen after caller-supplied credential code has - // run. That code can install an `Object.prototype.toJSON`, which - // `JSON.stringify` honours for the ordinary nested objects a snapshot - // contains, so a second assembly can produce a body that was never bounded - // or checked. - const body = assembleBody(endpoint, snapshot); - return { args: snapshot, body }; + return snapshot; } function serializeJson(value: unknown): string { @@ -696,12 +710,11 @@ export async function executeLocalIntegrationEndpoint( options: ExecuteLocalIntegrationEndpointOptions, ): Promise { throwIfCallerAborted(options.signal); - // A caller that already snapshotted supplies its own pre-auth body; this - // local snapshot covers direct callers, which have no credential step to - // straddle. - const snapshot = snapshotLocalIntegrationEndpointArguments(options.endpoint, options.args); - const args = snapshot.args; - const body = options.body ?? snapshot.body; + const args = snapshotAndValidateArguments(options.endpoint, options.args); + // Assemble only when the caller did not already do it before resolving a + // credential. Re-assembling here would run after that credential step, where + // a poisoned `toJSON` can throw even though the threaded body is sound. + const body = options.body ?? assembleBody(options.endpoint, args); const signalLease = createRequestSignal( options.signal, options.timeoutMs ?? INTEGRATION_REQUEST_TIMEOUT_MS, diff --git a/src/integrations/local-tool-source.test.ts b/src/integrations/local-tool-source.test.ts index a57ea072c8..ff4f4c19ca 100644 --- a/src/integrations/local-tool-source.test.ts +++ b/src/integrations/local-tool-source.test.ts @@ -577,6 +577,53 @@ describe("createLocalIntegrationToolSource", () => { ); }); + bodyDriftIt("does not re-serialize the body when a pre-auth body was threaded in", async () => { + // A `toJSON` that THROWS, not one that returns a value: a discarded second + // assembly is invisible when the poison returns, but fatal when it throws. + let sentBody: BodyInit | null | undefined; + let restored = false; + const restore = (): void => { + if (restored) return; + restored = true; + deleteProperty(Object.prototype, "toJSON"); + }; + + const source = _createLocalIntegrationToolSourceForTesting( + { + tools: ["brevo__create_contact"], + credentialProvider: () => { + defineProperty(Object.prototype, "toJSON", { + configurable: true, + value: () => { + throw new Error("toJSON poisoned after credential resolution"); + }, + writable: true, + }); + return TEST_CREDENTIAL; + }, + }, + (request) => { + sentBody = request.init.body; + restore(); + return Promise.resolve(Response.json({ contact: { id: "1" } })); + }, + ); + + try { + await source.executeTool("brevo__create_contact", { + email: "ada@example.test", + attributes: { FIRSTNAME: "Ada" }, + }); + } finally { + restore(); + } + + assertEquals( + sentBody, + '{"email":"ada@example.test","attributes":{"FIRSTNAME":"Ada"},"updateEnabled":false}', + ); + }); + it("rejects pre-aborted execution before resolving credentials", async () => { let credentialProviderCalls = 0; let transportCalls = 0;