@isomorph.ai/app-sdk 2.7.1 → 2.8.1

package/README.md

@@ -392,6 +392,32 @@ await isomorph.actions.invokePublic('signup', { email });
 
 (2.6.0)
 
+## Calling another app as the signed-in person
+
+An action calls another app of the company as the person who started it, with no credential:
+
+```ts
+// actions/my-account.ts in the Candidate Portal
+export default async function myAccount(_input: unknown) {
+  return isomorph.apps.invoke('shadowfax-ats', 'portal-account', { version: 2, operation: 'me' });
+}
+```
+
+The other app (named by its address, as `appApiUrl` takes it) lists this one in its `.isomorph/app.json`:
+`"callers": [{ "app": "candidate-portal", "actions": ["portal-account", "portal-*"] }]`. A pattern never reaches a
+trusted action; name a trusted action exactly. Its action sees the person in `ctx.user` (role `member`) and this app
+in `ctx.caller = { app, environment }` (`app` is the calling app's id; `local` under `isomorph dev` and
+`isomorph check`, where `app` is the calling address). `ctx.caller` is absent on its own pages, service and MCP calls.
+The call goes through this app's own gateway with the workload token and the person's context; a refusal is an
+`IsomorphError` with the gateway's category (`AUTH_REQUIRED`, `FORBIDDEN` when not listed, `NOT_FOUND`,
+`RATE_LIMITED`). It works only from an action a signed-in person started: a job keeps using a service credential.
+A journey of the called app plays the caller with a POST to `/_harbour/api/<action>` carrying
+`X-Harbour-Call-Host: <caller address>` and one of the check's identity tokens as the bearer.
+The input may be up to 16 MiB (5 MiB when the called app runs on a serverless cell), as on the direct
+integration route; the answer stays at most 4 MiB.
+
+(2.8.0, input limits 2.8.1; data plane ADR 2026-11-07)
+
 ## Browser read tools
 
 Install optional peers `ai` and `playwright-core@1.58.2`. Locally run `npx playwright-core install chromium --only-shell`; V2 packages Chromium in the existing app image. An existing system executable can be supplied as executablePath.

package/dist/index.d.ts

@@ -1953,6 +1953,10 @@ export interface ActionIdentity {
     trusted: boolean;
     transactionId?: string;
     baseUrl?: string;
+    /** The request id the action runs under, which a call to another app carries on. */
+    requestId?: string;
+    /** Brings ISOMORPH_WORKLOAD_TOKEN up to date (a serverless runtime's session is renewed on demand). */
+    workloadToken?: () => Promise<void>;
 }
 interface IdentityRenewal {
     renewals(): number;
@@ -2084,6 +2088,19 @@ export declare function createClient(options?: ClientOptions): {
          */
         invokePublic: <T = unknown>(name: string, input: unknown) => Promise<T>;
     };
+    apps: {
+        /**
+         * Call another app's action as the person who started this one: from an
+         * action's server code only, with no credential. The other app is named
+         * by its address name (what `appApiUrl` takes) and must list this app
+         * among its `callers` for the action in `.isomorph/app.json`; its action
+         * sees that person in `ctx.user` and this app in `ctx.caller`. A job has
+         * no signed-in person and calls with a service credential instead.
+         */
+        invoke: <T = unknown, P = string>(address: string, action: string, input: unknown, options?: {
+            onProgress?: (step: P) => void;
+        }) => Promise<T>;
+    };
     jobs: {
         /** Select the owner's folder for a declared configurable file trigger. */
         configureTrigger: (name: string, configuration: {

package/dist/index.js

@@ -872,6 +872,41 @@ export function createClient(options = {}) {
                 return body.data;
             },
         },
+        apps: {
+            /**
+             * Call another app's action as the person who started this one: from an
+             * action's server code only, with no credential. The other app is named
+             * by its address name (what `appApiUrl` takes) and must list this app
+             * among its `callers` for the action in `.isomorph/app.json`; its action
+             * sees that person in `ctx.user` and this app in `ctx.caller`. A job has
+             * no signed-in person and calls with a service credential instead.
+             */
+            invoke: async (address, action, input, options = {}) => {
+                if (typeof location !== 'undefined')
+                    throw new IsomorphError('VALIDATION_FAILED', 'isomorph.apps.invoke runs in an action\'s server code, not in the browser.', undefined, undefined, 400);
+                const current = currentAction();
+                if (!current?.context)
+                    throw new IsomorphError('AUTH_REQUIRED', 'isomorph.apps.invoke needs an action a signed-in person started; a job uses a service credential.', undefined, undefined, 401);
+                const environment = process.env;
+                const gateway = environment.ISOMORPH_GATEWAY_URL || environment.HARBOUR_GATEWAY_URL;
+                if (!gateway)
+                    throw new IsomorphError('UNAVAILABLE', 'This app has no gateway to call another app through (ISOMORPH_GATEWAY_URL is not set).', undefined, undefined, 503);
+                const host = new URL(appApiUrl(address)).host;
+                await current.workloadToken?.();
+                if (!environment.ISOMORPH_WORKLOAD_TOKEN)
+                    throw new IsomorphError('AUTH_REQUIRED', 'The action has no workload token to call another app with.', undefined, undefined, 401);
+                return new Transport({ baseUrl: gateway, fetch: transport.fetch }).json(`/_harbour/api/${encodeURIComponent(action)}`, {
+                    method: 'POST',
+                    body: JSON.stringify(input ?? {}),
+                    headers: {
+                        authorization: `Bearer ${environment.ISOMORPH_WORKLOAD_TOKEN}`,
+                        'x-harbour-call-host': host,
+                        'x-harbour-tx': undefined,
+                        ...(current.requestId ? { 'x-request-id': current.requestId } : {}),
+                    },
+                }, options.onProgress);
+            },
+        },
         jobs: {
             /** Select the owner's folder for a declared configurable file trigger. */
             configureTrigger: (name, configuration) => transport.json('/_harbour/integrations/trigger-config', { method: 'POST', body: JSON.stringify({ name, configuration }) }),

package/dist/runtime.d.ts

@@ -32,6 +32,18 @@ export interface ActionContext {
      * the outer one.
      */
     transaction<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Set when another app of the company called this action as the person
+     * signed into it (`isomorph.apps.invoke`), as the gateway verified: that
+     * app's id and the environment the call came from (`local` under
+     * `isomorph dev` and `isomorph check`, where `app` is the calling app's
+     * address name). Absent on this app's own pages, service and MCP calls.
+     */
+    caller?: ActionCaller;
+}
+export interface ActionCaller {
+    app: string;
+    environment: 'preview' | 'production' | 'local';
 }
 export interface RuntimeInventory {
     actions: string[];

package/dist/runtime.js

@@ -90,6 +90,9 @@ export const CANCEL_RUN_ACTION = 'isomorph-jobs-cancel';
 export const LIST_RUNS_ACTION = 'isomorph-jobs-list';
 const LOGICAL_NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 const MAX_BODY_BYTES = 1 << 20;
+// Another app's call (ctx.caller) carries what the gateway's direct route admits: 16 MiB to a cluster runtime, 5 MiB
+// to a Lambda; the gateway holds every other entrance to 1 MiB.
+const APP_CALL_MAX_BODY_BYTES = 16 << 20;
 const LEASE_MS = 5 * 60_000;
 const QUEUE_WORKERS = 2;
 const QUEUE_POLL_MS = 2_000;
@@ -122,6 +125,23 @@ const DATA_PATH_RETRY_MS = 3_000;
 const PROGRESS_MEDIA_TYPE = 'application/x-ndjson';
 const MAX_PROGRESS_EVENTS = 256;
 const MAX_PROGRESS_LINE_BYTES = 1 << 10;
+const CALLER_ENVIRONMENTS = ['preview', 'production', 'local'];
+/** The calling app the gateway verified (`X-Harbour-Verified-Caller-*`), when another app called. */
+function verifiedCaller(request) {
+    const app = header(request, 'X-Harbour-Verified-Caller-App');
+    const environment = header(request, 'X-Harbour-Verified-Caller-Environment');
+    return app && CALLER_ENVIRONMENTS.includes(environment) ? { app, environment: environment } : undefined;
+}
+/** `.isomorph/app.json` `callers` as written, for the local gateway to expand (`isomorph dev`); [] when there are none. */
+async function declaredCallers(root) {
+    try {
+        const callers = JSON.parse(await readFile(join(root, '.isomorph', 'app.json'), 'utf8')).callers;
+        return Array.isArray(callers) ? callers : [];
+    }
+    catch {
+        return [];
+    }
+}
 /** Every `actions/<name>.ts` and `jobs/<name>.ts` the app carries, by logical name. */
 export async function discover(root) {
     const list = async (dir) => {
@@ -208,12 +228,12 @@ function refusal(error) {
         return { status: REFUSAL_STATUS[code], category: code, message: error.message };
     return undefined;
 }
-async function readBody(request) {
+async function readBody(request, limit = MAX_BODY_BYTES) {
     const chunks = [];
     let size = 0;
     for await (const chunk of request) {
         size += chunk.length;
-        if (size > MAX_BODY_BYTES)
+        if (size > limit)
             return undefined;
         chunks.push(chunk);
     }
@@ -795,10 +815,12 @@ export class Runtime {
                 response.writeHead(200, { 'content-type': PROGRESS_MEDIA_TYPE, ...(requestId ? { 'x-request-id': requestId } : {}) });
             response.write(line);
         };
-        const context = { computerView: header(request, 'X-Harbour-Computer-View') === '1', signal: controller.signal, user, tenant, app, requestId: requestId ?? '', progress, transaction: (fn) => this.transaction(name, fn) };
-        const raw = await readBody(request);
+        const caller = verifiedCaller(request);
+        const context = { computerView: header(request, 'X-Harbour-Computer-View') === '1', signal: controller.signal, user, tenant, app, requestId: requestId ?? '', progress, transaction: (fn) => this.transaction(name, fn), ...(caller ? { caller } : {}) };
+        const limit = caller ? APP_CALL_MAX_BODY_BYTES : MAX_BODY_BYTES;
+        const raw = await readBody(request, limit);
         if (raw === undefined)
-            return refuse(response, 413, 'VALIDATION_FAILED', 'the request body is larger than 1 MiB', requestId);
+            return refuse(response, 413, 'VALIDATION_FAILED', `the request body is larger than ${limit >> 20} MiB`, requestId);
         if (name === 'isomorph-mail-arrival' && header(request, 'X-Harbour-Verified-Hook')) {
             // The gateway's hooks route: the provider's raw body and headers, the gateway's verified
             // headers beside them. The answer is what the provider reads, so it is not enveloped.
@@ -849,7 +871,7 @@ export class Runtime {
             await this.prepareAI();
             const handler = await loadHandler(this.options.root, ACTIONS_DIR, name);
             const trusted = this.inventory.trusted.includes(name);
-            const identity = { context: header(request, 'X-Harbour-Identity-Context'), trusted, baseUrl: trusted ? process.env.ISOMORPH_TRUSTED_GATEWAY_URL || undefined : undefined };
+            const identity = { context: header(request, 'X-Harbour-Identity-Context'), trusted, baseUrl: trusted ? process.env.ISOMORPH_TRUSTED_GATEWAY_URL || undefined : undefined, requestId, workloadToken: () => this.refreshToken() };
             const result = await actionIdentity.run(identity, () => handler(input, context));
             return answer(response, 200, { data: result === undefined ? null : result }, requestId);
         }
@@ -922,7 +944,9 @@ export class Runtime {
             case PING_ACTION: {
                 // `hooks` is what the local gateway's hooks entrance serves under `isomorph dev` (data plane ADR 0112).
                 const hooks = this.inventory.jobs.flatMap((job) => job.trigger?.type === 'webhook' ? [{ job: job.name, provider: job.trigger.provider }] : []);
-                const answer = { ok: true, mode: this.options.mode, actions: this.inventory.actions, trusted: this.inventory.trusted, exposed: this.inventory.exposed, public: this.inventory.public, jobs: this.inventory.jobs.map((job) => job.name), hooks };
+                // `callers` is what the local gateway admits another app's call by under `isomorph dev` (data plane ADR 2026-11-07).
+                const callers = await declaredCallers(this.options.root);
+                const answer = { ok: true, mode: this.options.mode, actions: this.inventory.actions, trusted: this.inventory.trusted, exposed: this.inventory.exposed, public: this.inventory.public, jobs: this.inventory.jobs.map((job) => job.name), hooks, ...(callers.length ? { callers } : {}) };
                 return this.options.mode === 'gate' ? { ...answer, loadFailures: await this.loadFailures() } : answer;
             }
             case ENQUEUE_ACTION: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/app-sdk",
-  "version": "2.7.1",
+  "version": "2.8.1",
   "type": "module",
   "repository": {
     "type": "git",