@hosty-sdk/app 0.35.1 → 0.38.0

package/dist/feedback-types.d.ts

@@ -0,0 +1,122 @@
+export type FeedbackRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type FeedbackTarget = {
+    kind: "element" | "region" | "page";
+    label?: string;
+    selector?: string;
+    bounds?: FeedbackRect;
+    viewport?: {
+        width: number;
+        height: number;
+        scale: number;
+    };
+};
+export type FeedbackNoteInput = {
+    id: string;
+    text: string;
+    route: string;
+    capturedAt: string;
+    target?: FeedbackTarget;
+    image?: {
+        mediaType: string;
+        data: string;
+    };
+};
+export type FeedbackSubmit = {
+    requestId: string;
+    comment: string;
+    annotations: FeedbackNoteInput[];
+    scope?: {
+        coreId: string;
+        appId: string;
+        installation: string;
+        userId: string;
+    };
+};
+export type FeedbackCapabilities = {
+    version: 1;
+    coreId: string;
+    appId: string;
+    installation: string;
+    userId: string;
+    maxAnnotations: number;
+    maxImageBytes: number;
+    maxTotalImageBytes: number;
+    administrator?: boolean;
+};
+export type FeedbackNote = Omit<FeedbackNoteInput, "image"> & {
+    mediaType: string | null;
+};
+export type FeedbackReport = {
+    id: string;
+    reporterId: string;
+    comment: string;
+    annotations: FeedbackNote[];
+    context: {
+        appId: string;
+        appName: string;
+        installation: string;
+        version: string | null;
+        observedAt: string;
+        executionKind: string;
+        workspaceId: string | null;
+        sourceRevision: string | null;
+    };
+    workspaceId: string | null;
+    revision: number;
+    status: string;
+    currentAttemptId: string | null;
+    disposition: string | null;
+};
+export type FeedbackSelection = {
+    id: string;
+    revision: number;
+};
+export type FeedbackDispatchInput = {
+    requestId: string;
+    sessionId: string;
+    workspaceId: string | null;
+    reports: FeedbackSelection[];
+    instruction: string;
+    appContextRevision?: number;
+    selectionRevision?: number;
+};
+export type FeedbackOutcome = {
+    reportId: string;
+    summary: string;
+    handledAnnotationIds: string[];
+    handled: boolean;
+};
+export type FeedbackDispatch = {
+    id: string;
+    callerAppId: string;
+    callerInstallation: string;
+    actorId: string;
+    input: FeedbackDispatchInput;
+    snapshot: FeedbackReport[];
+    createdAt: string;
+    state: string;
+    messageSequence: number | null;
+    workspaceId: string | null;
+    outcomes: FeedbackOutcome[] | null;
+    error: string | null;
+};
+export type FeedbackCollection = {
+    reports: FeedbackReport[];
+    dispatches: FeedbackDispatch[];
+};
+export type FeedbackDelivery = {
+    state: string;
+    messageSequence?: number;
+    workspaceId?: string | null;
+    error?: string;
+};
+export declare class FeedbackError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+}

package/dist/feedback-types.js

@@ -0,0 +1,9 @@
+export class FeedbackError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/index.d.ts

@@ -206,8 +206,3 @@ export declare function decideRecoveryAction(input: {
 }): RecoveryAction;
 /** Paint-time navigation policy. Kept in the pure entry point for Node and edge consumers. */
 export declare function chromeBootstrapScript(defaults?: import("./ui-types").UiChromeOverrides): string;
-/** Execution scope is independent of the principal's role. Never infer it from an app ID. */
-import type { SandboxTarget, SandboxIdentityContext } from "./sandbox-identity.js";
-export type { SandboxTarget, SandboxIdentityContext } from "./sandbox-identity.js";
-export declare function readSandboxTarget(environment: Record<string, string | undefined>): SandboxTarget | null;
-export declare function readSandboxIdentity(payload: Record<string, unknown>, expected: SandboxTarget | null): SandboxIdentityContext | null;

package/dist/index.js

@@ -269,24 +269,3 @@ export function chromeBootstrapScript(defaults = {}) {
         throw new Error("Invalid navigation default.");
     return `(()=>{try{const d=${JSON.stringify({ navigation })},p=new URLSearchParams(location.search),h=new URLSearchParams();for(const k of ["hosty_navigation","hosty_tools","hosty_tool_launcher","hosty_launch"])for(const v of p.getAll(k))h.append(k,v);document.documentElement.setAttribute('data-hosty-chrome-hints',h.toString());const one=k=>p.getAll(k).length===1?p.get(k):null,n=one('hosty_navigation'),l=one('hosty_launch');document.documentElement.setAttribute('data-hosty-navigation',n==='show'||n==='hide'?n:d.navigation??(l==='native'||l==='embedded'?'hide':'show'));}catch{}})();`;
 }
-export function readSandboxTarget(environment) {
-    const fields = [environment.HOSTY_SANDBOX_INSTANCE_ID, environment.HOSTY_SANDBOX_GENERATION, environment.HOSTY_SANDBOX_DATA_REVISION];
-    if (!environment.HOSTY_SANDBOX_PROTOCOL && fields.every(value => !value))
-        return null;
-    if (environment.HOSTY_SANDBOX_PROTOCOL !== "hosty-sandbox-v1" || fields.some(value => !/^[a-f0-9]{32}$/.test(value ?? "")))
-        throw new Error("The sandbox execution target is missing or unsupported.");
-    return { runtimeInstanceId: fields[0], generation: fields[1], dataRevision: fields[2] };
-}
-export function readSandboxIdentity(payload, expected) {
-    if (!expected) {
-        if (payload.identityRealm === "sandbox" || payload.runtimeInstanceId != null || payload.generation != null || payload.dataRevision != null)
-            throw new Error("An installed app cannot accept a sandbox identity.");
-        return null;
-    }
-    if (payload.runtimeInstanceId !== expected.runtimeInstanceId || payload.generation !== expected.generation || payload.dataRevision !== expected.dataRevision
-        || (payload.identityRealm !== "sandbox" && payload.identityRealm !== "core") || typeof payload.appRole !== "string"
-        || !Array.isArray(payload.permissions) || !payload.permissions.every(value => typeof value === "string")
-        || (payload.identityRealm === "sandbox" && payload.hostRole != null))
-        throw new Error("The identity belongs to a different or unsupported sandbox target.");
-    return { ...expected, identityRealm: payload.identityRealm, appRole: payload.appRole, permissions: payload.permissions };
-}

package/dist/overlay-react.js

@@ -7,7 +7,7 @@ import { useAppActivity } from "./activity-react.js";
 import { APP_SESSION_ENDED, APP_SESSION_RESTORED, APP_ACTIVITY_RENEWED, acceptAppAuthProtocol } from "./browser-auth.js";
 import { buildCoreOpenUrl, readRecoveryParams } from "./index.js";
 import { permissionReviewUrl, requestPermissionReview } from "./permissions.js";
-import { SdkBrand, SdkChromeStyles, SdkLoader } from "./sdk-chrome.js";
+import { SdkBrand, SdkChromeStyles, SdkIcon, SdkLoader } from "./sdk-chrome.js";
 import { HostyUiRoot } from "./ui-react.js";
 function snapshot(body) {
     const value = body;
@@ -19,6 +19,7 @@ function snapshot(body) {
     const openUrl = recovery.appId ? buildCoreOpenUrl(recovery.corePublicOrigin, recovery.appId, window.location) : null;
     // The activity policy remains authoritative even when renewal discovery fails.
     return { userId: value.userId, setup, notice: value.hosty?.notice,
+        permissionWarning: value.hosty?.permissionWarning === "unsupported",
         activityRequired: value.activityRequired === true,
         activeUntil: typeof value.activeUntil === "string" ? value.activeUntil : null,
         recoveryReady: !!openUrl && !!acceptAppAuthProtocol(new URL(openUrl).origin, recovery.appAuthProtocol) };
@@ -189,7 +190,7 @@ export function HostyOverlay({ children, probePath = "/api/hosty/session", appCo
     }
     const localOffline = (identity.ui.kind === "unavailable" || (identity.ui.kind === "active" && session?.setup === "unavailable"))
         && localContent !== undefined;
-    return _jsxs(_Fragment, { children: [localOffline && _jsxs("div", { "data-hosty-local-content": true, children: [_jsxs("div", { "data-hosty-sdk": true, className: "hosty-overlay-offline", role: "status", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkBrand, {}), _jsx("span", { children: "Hosty is unavailable. Local content remains available." }), _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { void refreshRef.current(); }, children: "Retry" })] }), localContent] }), _jsx("div", { "data-hosty-content": true, hidden: !ready, inert: !ready, style: ready ? { display: "contents" } : { display: "none" }, children: _jsx(HostyUiRoot, { chrome: chrome, navigation: navigation, uiPath: uiPath, panelLayout: panelLayout, active: ready, children: mounted.current ? children : null }) }), !ready && !localOffline && _jsx(OverlaySurface, { pending: pending, title: title, message: message, action: action, actionLabel: actionLabel, reviewUrl: reviewUrl })] });
+    return _jsxs(_Fragment, { children: [ready && session?.permissionWarning && _jsxs("div", { "data-hosty-sdk": true, role: "status", className: "hosty-overlay-offline", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkIcon, { name: "warning" }), _jsxs("span", { children: ["This Core does not support some permissions requested by this app. Update the app or Core. These permissions are not granted; some app features may not work.", session.notice?.permissions?.unsupportedRequired?.length ? ` (${session.notice.permissions.unsupportedRequired.join(", ")})` : ""] })] }), localOffline && _jsxs("div", { "data-hosty-local-content": true, children: [_jsxs("div", { "data-hosty-sdk": true, className: "hosty-overlay-offline", role: "status", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsx(SdkBrand, {}), _jsx("span", { children: "Hosty is unavailable. Local content remains available." }), _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { void refreshRef.current(); }, children: "Retry" })] }), localContent] }), _jsx("div", { "data-hosty-content": true, hidden: !ready, inert: !ready, style: ready ? { display: "contents" } : { display: "none" }, children: _jsx(HostyUiRoot, { chrome: chrome, navigation: navigation, uiPath: uiPath, panelLayout: panelLayout, active: ready, children: mounted.current ? children : null }) }), !ready && !localOffline && _jsx(OverlaySurface, { pending: pending, title: title, message: message, action: action, actionLabel: actionLabel, reviewUrl: reviewUrl })] });
 }
 function OverlaySurface({ pending, title, message, action, actionLabel, reviewUrl }) {
     const [portal, setPortal] = useState(null);

package/dist/permissions-react.js

@@ -42,9 +42,7 @@ export function MissingPermissionsNotice({ endpoint = "/api/hosty/permissions" }
     const kind = state && permissionNotice(state);
     if (dismissed || !kind || !state)
         return null;
-    return _jsxs("section", { "data-hosty-sdk": true, "data-hosty-activity-control": true, role: "alert", "aria-label": "Required permissions", className: "hosty-permissions-notice", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsxs("header", { children: [_jsx(SdkBrand, {}), _jsx(SdkIcon, { name: "warning" }), _jsx("strong", { children: "Permissions needed" })] }), kind === "unsupported"
-                ? _jsxs("p", { children: ["Core does not support required permissions: ", state.permissions.unsupportedRequired.join(", "), ". Update the app or Core."] })
-                : _jsx("p", { children: "This app needs required permissions. Operations using them are unavailable until approval." }), kind === "missing" && state.permissions?.reviewAvailable !== false && state.corePublicOrigin &&
+    return _jsxs("section", { "data-hosty-sdk": true, "data-hosty-activity-control": true, role: "alert", "aria-label": "Required permissions", className: "hosty-permissions-notice", children: [_jsx(SdkChromeStyles, {}), _jsx("style", { children: styles }), _jsxs("header", { children: [_jsx(SdkBrand, {}), _jsx(SdkIcon, { name: "warning" }), _jsx("strong", { children: "Permissions needed" })] }), !!state.permissions?.unsupportedRequired?.length && _jsxs("p", { children: ["This Core does not support requested permissions: ", state.permissions.unsupportedRequired.join(", "), ". Update the app or Core. These permissions are not granted; some app features may not work."] }), kind === "missing" && _jsx("p", { children: "This app needs required permissions. Operations using them are unavailable until approval." }), kind === "missing" && state.permissions?.reviewAvailable !== false && state.corePublicOrigin &&
                 _jsx("button", { type: "button", className: "hosty-sdk-button", onClick: () => { requestPermissionReview(state); setPending(true); }, children: "Request permissions" }), pending && _jsxs("p", { className: "hosty-sdk-status", children: [_jsx(SdkSpinner, {}), "Review permissions in Core, then return here. You can leave this app installed without approving."] }), _jsx("button", { type: "button", onClick: () => { setDismissed(true); setPending(false); }, className: "hosty-sdk-button hosty-sdk-ghost", children: "Dismiss" })] });
 }
 const styles = `

package/dist/permissions.js

@@ -4,9 +4,9 @@ export function permissionNotice(state) {
     if (state.hostRole !== "host.admin" || !state.permissions)
         return null;
     const p = state.permissions;
-    if (p.unsupportedRequired?.length)
-        return "unsupported";
-    return p.required.some(name => !p.granted.includes(name)) ? "missing" : null;
+    if (p.required.some(name => !p.unsupportedRequired?.includes(name) && !p.granted.includes(name)))
+        return "missing";
+    return p.unsupportedRequired?.length ? "unsupported" : null;
 }
 export function permissionReviewUrl(corePublicOrigin, appId) {
     const core = new URL(corePublicOrigin);

package/dist/providers-server.d.ts

@@ -30,6 +30,8 @@ export declare class ProviderClient {
     assistant(provider: Pick<ProviderDescriptor, "appId" | "key"> & {
         installationId?: string | null;
     }, userToken: () => Promise<string>): Promise<AssistantClient>;
+    /** Bounded task protocol transport. The selected installation is checked on every operation. */
+    taskRequest<T>(provider: import("./tasks.js").TaskProviderRef, kind: "tasks" | "task-executor", route: string, method: string, input?: unknown, userToken?: () => Promise<string>, signal?: AbortSignal): Promise<T>;
     /** Provider-side validation checks live grants on every request; never cache this result. */
     validate(token: string, kind: ProviderKind, key?: string, signal?: AbortSignal): Promise<ProviderInvocation>;
 }

package/dist/providers-server.js

@@ -79,6 +79,19 @@ export class ProviderClient {
             return { token: fresh.token };
         });
     }
+    /** Bounded task protocol transport. The selected installation is checked on every operation. */
+    async taskRequest(provider, kind, route, method, input, userToken, signal) {
+        const allowed = kind === "tasks"
+            ? /^(?:\/capabilities|\/tasks(?:\?[a-zA-Z0-9%=&_-]*|\/[a-zA-Z0-9-]+(?:\/actions)?)?)$/
+            : /^(?:\/options|\/executions\/[a-zA-Z0-9-]+(?:\/cancel)?)$/;
+        if (!allowed.test(route) || !["GET", "POST", "PATCH", "PUT"].includes(method))
+            throw new ProviderError("task_route_invalid", "Use a version-one task operation.", 400);
+        const binding = await this.connect({ ...provider, kind }, signal, await userToken?.());
+        return read(await fetch(`${binding.url}${route}`, { method, redirect: "error", cache: "no-store",
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000),
+            headers: { authorization: `Bearer ${binding.token}`, "content-type": "application/json" },
+            body: input === undefined ? undefined : JSON.stringify(input) }));
+    }
     /** Provider-side validation checks live grants on every request; never cache this result. */
     validate(token, kind, key = "default", signal) {
         return this.coreRequest("/provider/introspect", { token, kind, key }, signal);

package/dist/providers.d.ts

@@ -1,5 +1,5 @@
-/** Provider categories supported by Core. Agent execution is intentionally not part of this contract. */
-export type ProviderKind = "speech-to-text" | "assistant" | "translation";
+/** Provider categories supported by Core. Task execution does not expose model/profile configuration. */
+export type ProviderKind = "speech-to-text" | "assistant" | "translation" | "tasks" | "task-executor";
 export type ProviderDescriptor = {
     appId: string;
     displayName: string;

package/dist/sandbox-server.d.ts

@@ -1,39 +1,9 @@
 import type { ProviderServerOptions } from "./providers-server.js";
-export type SandboxSource = {
-    kind: "worktree";
-    worktreeId: string;
-} | {
-    kind: "appArtifact";
-    artifactDigest?: string;
-};
-export interface SandboxLimits {
-    memoryBytes?: number;
-    cpus?: number;
-    pids?: number;
-    dataBytes?: number;
-    cacheBytes?: number;
-    startupSeconds?: number;
-}
 export interface SandboxContext {
     workspaceId?: string;
     sessionId?: string;
     jobId?: string;
 }
-export interface SandboxPlanInput {
-    appId: string;
-    profile: string;
-    source: SandboxSource;
-    limits?: SandboxLimits;
-    context?: SandboxContext;
-}
-export interface SandboxPlan {
-    id: string;
-    digest: string;
-    inputDigest: string;
-    request: SandboxPlanInput;
-    blockers: string[];
-    expiresAt: string;
-}
 export interface SandboxOperation {
     id: string;
     kind: string;
@@ -41,96 +11,11 @@ export interface SandboxOperation {
     errorCode?: string;
     message?: string;
 }
-export interface SandboxUser {
-    id: string;
-    fixtureKey: string;
-    displayName: string;
-    role: string;
-    permissions: string[];
-    enabled: boolean;
-    revision: number;
-}
-export interface SandboxInstance {
-    id: string;
-    appId: string;
-    source: SandboxSource;
-    context?: SandboxContext;
-    revision: number;
-    generation: string;
-    dataRevision: string;
-    state: string;
-    previewUrl?: string;
-    errorCode?: string;
-    operations: SandboxOperation[];
-    users: SandboxUser[];
-    viewers?: string[];
-    endpoints?: {
-        key: string;
-        url: string;
-    }[];
-    metrics?: {
-        at: string;
-        memoryBytes: number | null;
-        sampledPeakMemoryBytes: number | null;
-        services: {
-            service: string;
-            memoryBytes: number | null;
-            cpuPercent: number | null;
-        }[];
-    };
-    storage?: {
-        at: string;
-        dataBytes: number;
-        seedBytes: number;
-        cacheBytes: number;
-        evidenceBytes: number;
-        totalBytes: number;
-        warning: boolean;
-        errorCode?: string;
-    };
-}
-export interface SandboxDiagnostics {
-    instanceId: string;
-    state: string;
-    errorCode?: string;
-    services: {
-        service: string;
-        state: string;
-        text: string;
-    }[];
-}
-export declare const sandboxActions: readonly ["sandbox-logs", "sandbox-plan", "sandbox-prepare", "sandbox-list", "sandbox-status", "sandbox-users", "sandbox-seed", "sandbox-start", "sandbox-restart", "sandbox-stop", "sandbox-reset", "sandbox-dispose", "sandbox-browser", "sandbox-export", "sandbox-user-delete", "sandbox-viewers", "sandbox-evidence-clear", "sandbox-preview", "sandbox-browser-cancel"];
-export type SandboxAction = typeof sandboxActions[number];
 export declare class SandboxError extends Error {
     readonly code: string;
     readonly status: number | null;
     constructor(code: string, message: string, status: number | null);
 }
-/** Server-only transport. The authority callback can supply an interactive grant or an explicitly
- * approved BackgroundGrantClient.token(); neither workspaces nor assistant roles are required. */
-export declare class SandboxClient {
-    private readonly authority;
-    private readonly origin;
-    private readonly appId;
-    private readonly service;
-    constructor(authority: () => Promise<string>, options?: ProviderServerOptions);
-    plan(input: SandboxPlanInput): Promise<SandboxPlan>;
-    prepare(input: {
-        requestId: string;
-        planId: string;
-        digest: string;
-    }): Promise<SandboxInstance>;
-    list(): Promise<{
-        instances: SandboxInstance[];
-    }>;
-    status(runtimeInstanceId: string): Promise<SandboxInstance>;
-    command(runtimeInstanceId: string, action: "start" | "restart" | "stop" | "reset" | "dispose", input: {
-        requestId: string;
-        expectedRevision: number;
-        seedRevision?: string;
-    }): Promise<SandboxInstance>;
-    call<T = unknown>(action: SandboxAction, input: Record<string, unknown>): Promise<T>;
-}
 export declare const coreEnvironmentActions: readonly ["environment-consent", "environment-create", "environment-list", "environment-status", "environment-start", "environment-stop", "environment-restart", "environment-finish", "environment-setup", "environment-api", "environment-initialization", "environment-initialization-resume", "environment-setup-link"];
 export type CoreEnvironmentAction = typeof coreEnvironmentActions[number];
 export interface CoreEnvironmentSavedConsent {
@@ -153,6 +38,7 @@ export interface CoreEnvironment {
     dataRoot?: string;
     previewUrl: string;
     initializationRequested?: boolean;
+    coreVersion?: string | null;
     process?: {
         pid: number;
         startedAt: string;

package/dist/sandbox-server.js

@@ -1,5 +1,3 @@
-export const sandboxActions = ["sandbox-logs", "sandbox-plan", "sandbox-prepare", "sandbox-list", "sandbox-status", "sandbox-users", "sandbox-seed",
-    "sandbox-start", "sandbox-restart", "sandbox-stop", "sandbox-reset", "sandbox-dispose", "sandbox-browser", "sandbox-export", "sandbox-user-delete", "sandbox-viewers", "sandbox-evidence-clear", "sandbox-preview", "sandbox-browser-cancel"];
 export class SandboxError extends Error {
     code;
     status;
@@ -10,89 +8,6 @@ export class SandboxError extends Error {
         this.name = "SandboxError";
     }
 }
-/** Server-only transport. The authority callback can supply an interactive grant or an explicitly
- * approved BackgroundGrantClient.token(); neither workspaces nor assistant roles are required. */
-export class SandboxClient {
-    authority;
-    origin;
-    appId;
-    service;
-    constructor(authority, options = {}) {
-        this.authority = authority;
-        this.origin = new URL(options.coreOrigin ?? process.env.HOSTY_CORE_ORIGIN ?? "http://127.0.0.1:7070");
-        this.appId = options.appId ?? process.env.HOSTY_APP_ID ?? "";
-        this.service = options.serviceToken ?? process.env.HOSTY_APP_SERVICE_TOKEN ?? "";
-        if (!this.appId || !this.service || !["http:", "https:"].includes(this.origin.protocol) || this.origin.username || this.origin.password
-            || this.origin.pathname !== "/" || this.origin.search || this.origin.hash)
-            throw new Error("A valid Core origin and calling app service identity are required.");
-    }
-    plan(input) { return this.call("sandbox-plan", input); }
-    prepare(input) { return this.call("sandbox-prepare", input); }
-    list() { return this.call("sandbox-list", {}); }
-    status(runtimeInstanceId) { return this.call("sandbox-status", { runtimeInstanceId }); }
-    command(runtimeInstanceId, action, input) {
-        return this.call(`sandbox-${action}`, { runtimeInstanceId, ...input });
-    }
-    async call(action, input) {
-        if (!sandboxActions.includes(action))
-            throw new SandboxError("sandbox_operation_invalid", "Unknown sandbox operation.", 400);
-        const { runtimeInstanceId, ...body } = input;
-        const jobId = body.jobId;
-        const root = `/api/internal/apps/${encodeURIComponent(this.appId)}/sandbox-instances`;
-        const read = action === "sandbox-logs" || action === "sandbox-list" || action === "sandbox-status" || action === "sandbox-export" || action === "sandbox-preview";
-        let suffix = "";
-        if (action === "sandbox-plan")
-            suffix = "/plans";
-        else if (action !== "sandbox-list" && action !== "sandbox-prepare") {
-            if (typeof runtimeInstanceId !== "string" || !/^[a-f0-9]{32}$/.test(runtimeInstanceId))
-                throw new SandboxError("sandbox_id_invalid", "Use the Core-issued runtime instance ID.", 400);
-            suffix = `/${runtimeInstanceId}`;
-            if (action === "sandbox-logs")
-                suffix += "/diagnostics";
-            else if (action === "sandbox-users")
-                suffix += "/users";
-            else if (action === "sandbox-user-delete")
-                suffix += "/users/delete";
-            else if (action === "sandbox-viewers")
-                suffix += "/viewers";
-            else if (action === "sandbox-evidence-clear")
-                suffix += "/evidence/clear";
-            else if (action === "sandbox-seed")
-                suffix += "/seeds";
-            else if (action === "sandbox-browser")
-                suffix += "/browser-runs";
-            else if (action === "sandbox-browser-cancel")
-                suffix += "/browser-runs/cancel";
-            else if (action === "sandbox-preview")
-                suffix += "/preview" + (typeof body.userId === "string" ? "?userId=" + encodeURIComponent(body.userId) : "");
-            else if (action === "sandbox-export") {
-                if (typeof jobId !== "string" || !/^[a-f0-9]{32}$/.test(jobId))
-                    throw new SandboxError("sandbox_job_invalid", "Select a recorded browser run.", 400);
-                suffix += `/browser-runs/${jobId}`;
-            }
-            else if (!read)
-                suffix += `/operations/${action.slice("sandbox-".length)}`;
-        }
-        if (!read && action !== "sandbox-plan" && (typeof body.requestId !== "string" || !/^[a-f0-9-]{32,36}$/i.test(body.requestId)))
-            throw new SandboxError("sandbox_request_required", "Persist a request UUID before sending a mutation. Replay the same UUID and arguments after an uncertain result.", 400);
-        const credential = await this.authority();
-        let response;
-        try {
-            response = await fetch(new URL(root + suffix, this.origin), { method: read ? "GET" : "POST", redirect: "error", cache: "no-store",
-                headers: { authorization: `Bearer ${this.service}`, "X-Hosty-User-Token": credential, "content-type": "application/json" },
-                body: read ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(action === "sandbox-browser" ? 330_000 : 180_000) });
-        }
-        catch {
-            throw new SandboxError("sandbox_outcome_unknown", "Core could not confirm the outcome. Read the operation or replay its original request UUID and arguments.", null);
-        }
-        const result = await response.json().catch(() => null);
-        if (!result)
-            throw new SandboxError("sandbox_outcome_unknown", "Core returned no readable outcome; keep the original operation identity.", response.status);
-        if (!response.ok)
-            throw new SandboxError(result.code ?? "sandbox_failed", result.message ?? "Sandbox request failed.", response.status);
-        return result;
-    }
-}
 export const coreEnvironmentActions = ["environment-consent", "environment-create", "environment-list", "environment-status", "environment-start",
     "environment-stop", "environment-restart", "environment-finish", "environment-setup", "environment-api", "environment-initialization", "environment-initialization-resume", "environment-setup-link"];
 /** Full child Core transport. Requires core.environments permissions and live administrator authority.

package/dist/server.d.ts

@@ -1,5 +1,4 @@
 import "server-only";
-import { type SandboxIdentityContext } from "./index.js";
 import { type AppContinuity } from "./continuity.js";
 import { type AppAuthProtocol } from "./app-code.js";
 export { isValidCodeVerifier } from "./app-code.js";
@@ -28,8 +27,6 @@ export interface HostIdentity {
     activeUntil?: string | null;
     activityRequired?: boolean;
     continuity?: AppContinuity;
-    /** Present for every identity (including real viewers) acting inside a sandbox. */
-    sandbox?: SandboxIdentityContext;
 }
 /** Structured detail for a failed resolution: the Core HTTP status (null when Core was
  * never reached) plus a machine-readable code and human-readable message. Codes pass

package/dist/server.js

@@ -1,7 +1,6 @@
 // Server slice: Next route-handler factories and Core revalidation. Never reaches a client
 // bundle — the service token lives here.
 import "server-only";
-import { readSandboxTarget, readSandboxIdentity } from "./index.js";
 import { readAppContinuity } from "./continuity.js";
 import { createHostySessionResponse } from "./session-server.js";
 import { createHostyUiResponse } from "./ui-server.js";
@@ -68,8 +67,6 @@ export function readAppIdentityToken(headers, config) {
             return token;
         }
     }
-    if (process.env.HOSTY_SANDBOX_PROTOCOL)
-        return headers.get(HOSTY_APP_IDENTITY_HEADER)?.trim() || readCookie(headers.get("cookie"), config.identityCookieName) || null;
     return readCookie(headers.get("cookie"), config.identityCookieName) || headers.get(HOSTY_APP_IDENTITY_HEADER)?.trim() || null;
 }
 /** True when the effective request protocol is https (honouring the forwarded proto). */
@@ -122,8 +119,7 @@ export async function resolveAppSession(token, config) {
         };
     }
     const now = Date.now();
-    // Synthetic subject changes and instance revocation are checked online on every request.
-    const cached = process.env.HOSTY_SANDBOX_PROTOCOL ? undefined : revalidationCache.get(token);
+    const cached = revalidationCache.get(token);
     if (cached) {
         if (now - cached.cachedAt < REVALIDATION_CACHE_TTL_MS && now < cached.expiresAtMs) {
             return { status: "active", identity: cached.identity };
@@ -215,13 +211,6 @@ async function revalidateWithCore(token, coreOrigin, serviceToken, config) {
     if (!payload || payload.active !== true || !userId) {
         return { status: "expired" };
     }
-    let sandbox;
-    try {
-        sandbox = readSandboxIdentity(payload, readSandboxTarget(process.env));
-    }
-    catch {
-        return { status: "forbidden", error: { status: 403, code: "sandbox_identity_mismatch", message: "The identity does not match this execution target." } };
-    }
     const hostRole = readString(payload.hostRole);
     const expiresAt = readString(payload.expiresAt);
     const identity = {
@@ -229,15 +218,14 @@ async function revalidateWithCore(token, coreOrigin, serviceToken, config) {
         email: readString(payload.email),
         displayName: readString(payload.displayName),
         hostRole,
-        appRole: sandbox?.identityRealm === "sandbox" ? sandbox.appRole : config.mapHostRole ? config.mapHostRole(hostRole) : hostRole,
+        appRole: config.mapHostRole ? config.mapHostRole(hostRole) : hostRole,
         expiresAt,
         activeUntil: readString(payload.activeUntil),
         activityRequired: payload.activityRequired === true,
         continuity: readAppContinuity(payload.continuity),
-        ...(sandbox ? { sandbox } : {}),
     };
     const expiresAtMs = expiresAt ? Date.parse(expiresAt) : Number.NaN;
-    if (!sandbox && Number.isFinite(expiresAtMs) && expiresAtMs > Date.now()) {
+    if (Number.isFinite(expiresAtMs) && expiresAtMs > Date.now()) {
         pruneRevalidationCache();
         revalidationCache.set(token, { identity, expiresAtMs, cachedAt: Date.now() });
     }

package/dist/session-server.d.ts

@@ -1,6 +1,5 @@
 import { type ProviderServerOptions } from "@hosty-sdk/app/providers/server";
 import type { AppSessionStatus, SessionRecoveryParams } from "./session-types.js";
-import type { SandboxIdentityContext } from "./sandbox-identity.js";
 import type { AppContinuity } from "./continuity.js";
 /** Framework-neutral server adapter. Call with an already authenticated app session, never request data. */
 export type HostySessionInput = {
@@ -11,7 +10,6 @@ export type HostySessionInput = {
         activeUntil?: string | null;
         activityRequired?: boolean;
         continuity?: AppContinuity;
-        sandbox?: SandboxIdentityContext;
     };
     error?: {
         code: string;

package/dist/session-server.js

@@ -7,20 +7,15 @@ export async function createHostySessionResponse(session, recovery, options = {}
     const identity = session.identity;
     if (options.administratorOnly && identity.hostRole !== "host.admin")
         return Response.json({ status: "forbidden", recovery }, { headers });
-    if (identity.sandbox) {
-        // Core admits only recipes without required global permissions in this offline profile.
-        // The revalidated execution identity is authoritative; never query the installed app's
-        // permission state or advertise a global permission-review action from a test realm.
-        return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup: "ready" } }, { headers });
-    }
     let setup = "unavailable";
+    let permissionWarning;
     let notice;
     try {
         const permissions = await new ProviderClient({ ...options, appId: recovery.appId ?? undefined }).permissions(options.signal);
         if (![permissions.required, permissions.optional, permissions.granted, permissions.unsupportedRequired ?? []].every(list => Array.isArray(list) && list.every(name => typeof name === "string")))
             throw new Error("Invalid permission state.");
-        setup = permissions.unsupportedRequired?.length ? "unsupported"
-            : permissions.required.some(name => !permissions.granted.includes(name)) ? "missing" : "ready";
+        setup = permissions.required.some(name => !permissions.unsupportedRequired?.includes(name) && !permissions.granted.includes(name)) ? "missing" : "ready";
+        permissionWarning = permissions.unsupportedRequired?.length ? "unsupported" : undefined;
         if (identity.hostRole === "host.admin")
             notice = { hostRole: identity.hostRole, appId: recovery.appId ?? "",
                 corePublicOrigin: recovery.corePublicOrigin, permissions };
@@ -29,5 +24,5 @@ export async function createHostySessionResponse(session, recovery, options = {}
         if (error instanceof ProviderError && error.status === 404)
             setup = "incompatible";
     }
-    return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup, notice } }, { headers });
+    return Response.json({ status: "active", ...identity, recovery, hosty: { version: 1, setup, permissionWarning, notice } }, { headers });
 }