@hosty-sdk/app 0.35.1 → 0.38.0

package/dist/tasks-server.d.ts

@@ -0,0 +1,33 @@
+import type { ProviderClient } from "./providers-server.js";
+import type { TaskProviderRef, TaskRef, TaskRecord, TaskPage, TaskCreate, TaskEdit, TaskAction, TaskStatus, TaskCapabilities, TaskExecutorOptions, TaskExecutionInput, TaskExecutionReceipt } from "./tasks.js";
+/** Server-side task API. Every request obtains a fresh Core binding; no mutation is retried implicitly. */
+export declare class TaskClient {
+    private readonly providers;
+    private readonly provider;
+    private readonly userToken?;
+    constructor(providers: ProviderClient, provider: TaskProviderRef, userToken?: (() => Promise<string>) | undefined);
+    private call;
+    private id;
+    capabilities(signal?: AbortSignal): Promise<TaskCapabilities>;
+    list(options?: {
+        cursor?: string;
+        limit?: number;
+        status?: TaskStatus;
+        signal?: AbortSignal;
+    }): Promise<TaskPage>;
+    create(input: TaskCreate, signal?: AbortSignal): Promise<TaskRecord>;
+    get(ref: TaskRef, signal?: AbortSignal): Promise<TaskRecord>;
+    edit(ref: TaskRef, input: TaskEdit, signal?: AbortSignal): Promise<TaskRecord>;
+    action(ref: TaskRef, input: TaskAction, signal?: AbortSignal): Promise<TaskRecord>;
+}
+export declare class TaskExecutorClient {
+    private readonly providers;
+    private readonly executor;
+    private readonly userToken?;
+    constructor(providers: ProviderClient, executor: TaskProviderRef, userToken?: (() => Promise<string>) | undefined);
+    private call;
+    options(signal?: AbortSignal): Promise<TaskExecutorOptions>;
+    accept(executionId: string, input: TaskExecutionInput, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+    get(executionId: string, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+    cancel(executionId: string, requestId: string, signal?: AbortSignal): Promise<TaskExecutionReceipt>;
+}

package/dist/tasks-server.js

@@ -0,0 +1,57 @@
+/** Server-side task API. Every request obtains a fresh Core binding; no mutation is retried implicitly. */
+export class TaskClient {
+    providers;
+    provider;
+    userToken;
+    constructor(providers, provider, userToken) {
+        this.providers = providers;
+        this.provider = provider;
+        this.userToken = userToken;
+    }
+    call(route, method = "GET", input, signal) {
+        return this.providers.taskRequest(this.provider, "tasks", route, method, input, this.userToken, signal);
+    }
+    id(ref) {
+        if (ref.appId !== this.provider.appId || ref.installationId !== this.provider.installationId || ref.key !== this.provider.key)
+            throw new Error("The task belongs to another provider installation.");
+        return encodeURIComponent(ref.id);
+    }
+    capabilities(signal) { return this.call("/capabilities", "GET", undefined, signal); }
+    list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.cursor)
+            query.set("cursor", options.cursor);
+        if (options.limit !== undefined)
+            query.set("limit", String(options.limit));
+        if (options.status)
+            query.set("status", options.status);
+        return this.call(`/tasks?${query}`, "GET", undefined, options.signal);
+    }
+    create(input, signal) { return this.call("/tasks", "POST", input, signal); }
+    get(ref, signal) { return this.call(`/tasks/${this.id(ref)}`, "GET", undefined, signal); }
+    edit(ref, input, signal) { return this.call(`/tasks/${this.id(ref)}`, "PATCH", input, signal); }
+    action(ref, input, signal) { return this.call(`/tasks/${this.id(ref)}/actions`, "POST", input, signal); }
+}
+export class TaskExecutorClient {
+    providers;
+    executor;
+    userToken;
+    constructor(providers, executor, userToken) {
+        this.providers = providers;
+        this.executor = executor;
+        this.userToken = userToken;
+    }
+    call(route, method = "GET", input, signal) {
+        return this.providers.taskRequest(this.executor, "task-executor", route, method, input, this.userToken, signal);
+    }
+    options(signal) { return this.call("/options", "GET", undefined, signal); }
+    accept(executionId, input, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}`, "PUT", input, signal);
+    }
+    get(executionId, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}`, "GET", undefined, signal);
+    }
+    cancel(executionId, requestId, signal) {
+        return this.call(`/executions/${encodeURIComponent(executionId)}/cancel`, "POST", { requestId }, signal);
+    }
+}

package/dist/tasks.d.ts

@@ -0,0 +1,148 @@
+/** Core's version-one task contract. Numbers are opaque; references bind an installation. */
+export type TaskProviderRef = {
+    appId: string;
+    installationId: string;
+    key: string;
+};
+export type TaskRef = TaskProviderRef & {
+    id: string;
+};
+export type TaskStatus = "Draft" | "Ready" | "InProgress" | "Blocked" | "Done" | "Cancelled";
+export type TaskResource = {
+    kind: "app" | "workspace" | "external";
+    owner: string;
+    id: string;
+    label?: string;
+    version: {
+        mode: "live";
+    } | {
+        mode: "pinned";
+        revision: string;
+    };
+};
+export type TaskAssignee = {
+    kind: "human";
+    userId: string;
+    name?: string;
+} | {
+    kind: "app";
+    executor: TaskProviderRef;
+    optionId?: string;
+    name?: string;
+};
+export type TaskInput = {
+    title: string;
+    markdown: string;
+    assignee: TaskAssignee | null;
+    requiresReview: boolean;
+    resources: TaskResource[];
+    workspaceId?: string;
+};
+export type TaskActor = {
+    userId: string | null;
+    appId: string | null;
+    installationId?: string;
+};
+export type TaskResult = {
+    markdown: string;
+    resources: TaskResource[];
+};
+export type TaskExecutionState = "accepted" | "running" | "awaiting_input" | "cancelling" | "completed" | "failed" | "cancelled" | "interrupted";
+export type TaskExecutionInput = {
+    taskRef: TaskRef;
+    taskRevision: number;
+    executorOptionId?: string;
+    input: Omit<TaskInput, "assignee">;
+};
+export type TaskExecutionReceipt = {
+    executionId: string;
+    revision: number;
+    state: TaskExecutionState;
+    stopConfirmed: boolean;
+    createdAt: string;
+    updatedAt: string;
+    result?: TaskResult;
+    error?: {
+        code: string;
+        message: string;
+    }; /** An absolute HTTP(S) UI URL for cross-app readers; same-app readers can resolve a local path. */
+    sessionRef?: {
+        id: string;
+        path: string;
+    };
+};
+export type TaskAttempt = {
+    executionId: string;
+    executor: TaskProviderRef;
+    request: TaskExecutionInput;
+    receipt?: TaskExecutionReceipt;
+    cancelRequested: boolean;
+    createdAt: string;
+};
+export type TaskOutcome = {
+    inputRevision: number;
+    result: TaskResult;
+    recordedAt: string;
+    executionId?: string;
+};
+export type TaskRecord = TaskInput & {
+    ref: TaskRef;
+    number: string;
+    revision: number;
+    inputRevision: number;
+    status: TaskStatus;
+    createdBy: TaskActor;
+    owner: TaskActor;
+    createdAt: string;
+    updatedAt: string;
+    blocked?: {
+        reason: string;
+        message: string;
+    };
+    cancelRequested: boolean;
+    result?: TaskResult;
+    resultInputRevision?: number;
+    attempts: TaskAttempt[];
+    outcomes?: TaskOutcome[];
+};
+export type TaskMutation = {
+    requestId: string;
+    expectedRevision: number;
+};
+export type TaskInputWrite = Omit<TaskInput, "requiresReview"> & {
+    requiresReview?: boolean;
+};
+export type TaskCreate = {
+    requestId: string;
+    input: TaskInputWrite;
+};
+export type TaskEdit = TaskMutation & {
+    input: TaskInputWrite;
+};
+export type TaskAction = TaskMutation & {
+    action: "ready" | "draft" | "start" | "complete" | "cancel" | "accept" | "request_changes";
+    result?: TaskResult;
+    resultInputRevision?: number;
+    feedback?: string;
+};
+export type TaskPage = {
+    tasks: TaskRecord[];
+    nextCursor: string | null;
+};
+export type TaskCapabilities = {
+    version: 1;
+    prefix: string;
+    statuses: TaskStatus[];
+    maxPageSize: number;
+};
+export type TaskExecutorOption = {
+    id: string;
+    name: string;
+    capabilities: string[];
+};
+export type TaskExecutorOptions = {
+    options: TaskExecutorOption[];
+    defaultId: string | null;
+};
+export declare const taskStatuses: TaskStatus[];
+export declare const taskExecutionTerminal: (state: TaskExecutionState) => boolean;

package/dist/tasks.js

@@ -0,0 +1,2 @@
+export const taskStatuses = ["Draft", "Ready", "InProgress", "Blocked", "Done", "Cancelled"];
+export const taskExecutionTerminal = (state) => ["completed", "failed", "cancelled", "interrupted"].includes(state);

package/dist/ui-frame.js

@@ -137,5 +137,5 @@ export function HostyAppFrame(props) {
     const insecure = typeof window !== "undefined" && window.location.protocol === "https:" && new URL(surface.origin).protocol === "http:";
     if (insecure)
         return _jsxs("div", { "data-hosty-sdk": true, role: "status", className: "hosty-panel-notice", children: [_jsx(SdkChromeStyles, {}), _jsxs("strong", { children: [title, " needs HTTPS to appear here"] }), _jsx("p", { children: "This app publishes an HTTP address. Configure its public HTTPS origin in Hosty." }), /^(localhost|127\.|\[::1\])/.test(new URL(surface.origin).hostname) && _jsx("p", { children: "This local address is reachable only from the Hosty computer." }), standaloneHref && _jsx("a", { href: standaloneHref, target: "_blank", rel: "noopener noreferrer", children: "Open separately" })] });
-    return _jsxs(_Fragment, { children: [review && _jsxs(_Fragment, { children: [_jsx(SdkChromeStyles, {}), _jsx("a", { "data-hosty-sdk": true, className: "hosty-panel-review", href: review, target: "_blank", rel: "noopener noreferrer", children: "Review access in Core" })] }), _jsx("iframe", { ref: ref, className: className, title: title, src: launch, sandbox: frameSandbox(surface.framePolicy), allow: surface.framePolicy.microphone ? "clipboard-write; microphone 'src'" : "clipboard-write", style: { border: 0, height: "100%", width: "100%", colorScheme: resolvedTheme }, onLoad: () => setLoaded(true) })] });
+    return _jsxs(_Fragment, { children: [review && _jsxs(_Fragment, { children: [_jsx(SdkChromeStyles, {}), _jsx("a", { "data-hosty-sdk": true, className: "hosty-panel-review", href: review, target: "_blank", rel: "noopener noreferrer", children: "Review access in Core" })] }), _jsx("iframe", { ref: ref, className: className, title: title, src: launch, sandbox: frameSandbox(surface.framePolicy), allow: surface.framePolicy.microphone ? "clipboard-write; display-capture 'src'; microphone 'src'" : "clipboard-write; display-capture 'src'", style: { border: 0, height: "100%", width: "100%", colorScheme: resolvedTheme }, onLoad: () => setLoaded(true) })] });
 }

package/dist/ui-react.js

@@ -1,5 +1,6 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { FeedbackCapture } from "./feedback-react.js";
 import { SdkChromeStyles, SdkIcon } from "./sdk-chrome.js";
 import { useContext, useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
 import { bindUiClient, ui } from "./ui.js";
@@ -53,7 +54,7 @@ export function HostyUiRoot({ children, uiPath, panelLayout = "auto", active = t
     if (allowed)
         mounted.current = true;
     const content = _jsxs("div", { className: "hosty-app-layout", children: [navigation?.renderer !== "custom" && _jsx(HostyNavigation, {}), _jsxs("div", { className: "hosty-app-content", "data-hosty-content": true, tabIndex: -1, children: [_jsx(HostyToolLauncher, {}), children] })] });
-    return _jsx(UiHostContext.Provider, { value: host, children: _jsx(UiCompositionContext.Provider, { value: clientRef.current?.composition ?? null, children: _jsxs(UiFrameLayerContext.Provider, { value: layer, children: [_jsx("style", { children: `.hosty-app-layout{display:flex;width:100%;height:100%;min-width:0;min-height:0}.hosty-app-content{flex:1;min-width:0;min-height:0;overflow:auto;outline:none}` }), _jsx("div", { hidden: !allowed, inert: !allowed, style: { display: allowed ? "contents" : "none" }, children: mounted.current && (panelLayout === "auto" && host ? _jsx(HostyPanelWorkspace, { children: content }) : content) }), !allowed && _jsxs("div", { "data-hosty-sdk": true, role: "status", className: "hosty-panel-notice", children: [_jsx(SdkChromeStyles, {}), environment?.connection === "blocked" ? _jsxs(_Fragment, { children: [_jsx("strong", { children: environment.code === "actor_mismatch" ? "Use the same Hosty account in this app and its host" : "Cannot verify this app’s host" }), _jsx("p", { children: "Check your account and access in Hosty Core, then reconnect. Your existing discussion is unchanged." }), _jsx("button", { type: "button", onClick: () => window.location.reload(), children: "Reconnect" })] }) : "Connecting to the workspace…"] }), host && _jsx(HostyPresentationLayer, { layer: layer, host: host, active: !!allowed })] }) }) });
+    return _jsx(UiHostContext.Provider, { value: host, children: _jsx(UiCompositionContext.Provider, { value: clientRef.current?.composition ?? null, children: _jsxs(UiFrameLayerContext.Provider, { value: layer, children: [_jsx("style", { children: `.hosty-app-layout{display:flex;width:100%;height:100%;min-width:0;min-height:0}.hosty-app-content{flex:1;min-width:0;min-height:0;overflow:auto;outline:none}` }), _jsx("div", { hidden: !allowed, inert: !allowed, style: { display: allowed ? "contents" : "none" }, children: mounted.current && (panelLayout === "auto" && host ? _jsx(HostyPanelWorkspace, { children: content }) : content) }), !allowed && _jsxs("div", { "data-hosty-sdk": true, role: "status", className: "hosty-panel-notice", children: [_jsx(SdkChromeStyles, {}), environment?.connection === "blocked" ? _jsxs(_Fragment, { children: [_jsx("strong", { children: environment.code === "actor_mismatch" ? "Use the same Hosty account in this app and its host" : "Cannot verify this app’s host" }), _jsx("p", { children: "Check your account and access in Hosty Core, then reconnect. Your existing discussion is unchanged." }), _jsx("button", { type: "button", onClick: () => window.location.reload(), children: "Reconnect" })] }) : "Connecting to the workspace…"] }), _jsx(FeedbackCapture, { active: active && !!allowed, uiPath: uiPath }), host && _jsx(HostyPresentationLayer, { layer: layer, host: host, active: !!allowed })] }) }) });
 }
 const empty = { bootstrap: null, catalog: [], tools: [], selected: null, expanded: false, width: 360, error: null };
 const noop = () => () => { };

package/dist/ui-server.d.ts

@@ -1,4 +1,3 @@
-import type { SandboxIdentityContext } from "./sandbox-identity.js";
 import type { ProviderServerOptions } from "@hosty-sdk/app/providers/server";
 import { type ToolActivity, type PanelTarget, type UiBootstrap, type UiPanel, type UiResolvedPanel, type UiNavigationCatalog, type UiNavigationTarget, type UiResolvedNavigation } from "@hosty-sdk/app/ui/types";
 /** Server transport for generic UI metadata. Credentials never appear in returned metadata. */
@@ -22,7 +21,6 @@ type UiAuthenticatedContext = {
         status: "active";
         identity: {
             hostRole: string | null;
-            sandbox?: SandboxIdentityContext;
         };
     } | {
         status: "not-present" | "expired" | "forbidden" | "unavailable" | "misconfigured";

package/dist/ui-server.js

@@ -1,3 +1,7 @@
+import { FeedbackServerClient } from "@hosty-sdk/app/feedback/server";
+import { FeedbackError } from "@hosty-sdk/app/feedback";
+import { ProviderClient } from "@hosty-sdk/app/providers/server";
+import { ProviderError } from "@hosty-sdk/app/providers";
 import { UiError } from "@hosty-sdk/app/ui/types";
 /** Server transport for generic UI metadata. Credentials never appear in returned metadata. */
 export class UiServerClient {
@@ -58,14 +62,43 @@ export async function createHostyUiResponse(request, context, options = {}) {
         }
         if (options.administratorOnly && context.session.identity.hostRole !== "host.admin")
             throw new UiError("admin_required", "This application requires administrator access.", 403);
-        if (context.session.identity.sandbox)
-            throw new UiError("unsupported_sandbox_ui", "Global application panels are unavailable inside this sandbox profile.", 409);
         const url = new URL(request.url);
         const prefix = (options.uiPath ?? "/api/hosty/ui").replace(/\/$/, "");
         const route = url.pathname.startsWith(prefix + "/") ? url.pathname.slice(prefix.length + 1) : "";
         const client = new UiServerClient(options);
         let result;
-        if (request.method === "GET" && route === "bootstrap") {
+        if (/^feedback\/[a-f0-9]{64}\/review-targets$/.test(route) && request.method === "GET") {
+            result = await new FeedbackServerClient(options).reviewTargets(route.split("/")[1], context.token, request.signal);
+        }
+        else if (route === "feedback/speech" && request.method === "GET") {
+            const speech = new ProviderClient(options), permissions = await speech.permissions(request.signal);
+            const granted = permissions.granted.includes("providers.speech-to-text");
+            result = { granted, providers: granted ? await speech.list("speech-to-text", request.signal) : [] };
+        }
+        else if (route === "feedback/speech" && request.method === "POST") {
+            if (!sameOrigin(request) || request.headers.get("content-type")?.split(";", 1)[0]?.trim() !== "application/json")
+                throw new UiError("origin_denied", "Dictate from this application page.", 403);
+            const speech = new ProviderClient(options), roster = await speech.list("speech-to-text", request.signal);
+            const input = JSON.parse(await boundedBody(request, 6 * 1024 * 1024));
+            if (!input || typeof input.appId !== "string" || typeof input.key !== "string" || typeof input.audio !== "string")
+                throw new UiError("speech_invalid", "Choose a speech provider and a recording.", 400);
+            if (!roster.some(p => p.appId === input.appId && p.key === input.key && p.available))
+                throw new UiError("speech_unavailable", "The selected speech provider is unavailable.", 409);
+            const bytes = Uint8Array.from(Buffer.from(input.audio, "base64"));
+            if (bytes.length < 44 || bytes.length > 120 * 16000 * 2 + 4096 || String.fromCharCode(...bytes.subarray(0, 4)) !== "RIFF" || String.fromCharCode(...bytes.subarray(8, 12)) !== "WAVE")
+                throw new UiError("speech_invalid", "Use a bounded WAV recording.", 400);
+            result = await speech.transcribe(input, new Blob([bytes], { type: "audio/wav" }), { signal: request.signal });
+        }
+        else if (route === "feedback" && request.method === "GET") {
+            result = await new FeedbackServerClient(options).capabilities(context.token, request.signal);
+        }
+        else if (route === "feedback" && request.method === "POST") {
+            if (!sameOrigin(request) || request.headers.get("content-type")?.split(";", 1)[0]?.trim() !== "application/json")
+                throw new UiError("origin_denied", "Submit feedback from this application page.", 403);
+            const body = await boundedBody(request, 12 * 1024 * 1024);
+            result = await new FeedbackServerClient(options).submit(JSON.parse(body), context.token, request.signal);
+        }
+        else if (request.method === "GET" && route === "bootstrap") {
             if ([...url.searchParams.keys()].some(k => k !== "parentOrigin") || url.searchParams.getAll("parentOrigin").length > 1)
                 throw new UiError("ui_request_invalid", "Invalid bootstrap request.", 400);
             result = await client.bootstrap({ parentOrigin: url.searchParams.get("parentOrigin") ?? undefined }, context.token, request.signal);
@@ -95,12 +128,12 @@ export async function createHostyUiResponse(request, context, options = {}) {
         return Response.json(result, { headers: responseHeaders });
     }
     catch (error) {
-        const known = error instanceof UiError;
+        const known = error instanceof UiError || error instanceof FeedbackError || error instanceof ProviderError;
         return Response.json({ code: known ? error.code : error instanceof SyntaxError ? "ui_request_invalid" : "ui_unavailable",
             message: known ? error.message : "Application panels are unavailable. Retry opening the same target." }, { status: known ? error.status : error instanceof SyntaxError ? 400 : 503, headers: responseHeaders });
     }
 }
-async function boundedBody(request) {
+async function boundedBody(request, limit = 16_384) {
     const reader = request.body?.getReader();
     if (!reader)
         return "";
@@ -112,7 +145,7 @@ async function boundedBody(request) {
             if (done)
                 break;
             length += value.byteLength;
-            if (length > 16_384) {
+            if (length > limit) {
                 await reader.cancel();
                 throw new UiError("ui_request_invalid", "Panel request is too large.", 413);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hosty-sdk/app",
-  "version": "0.35.1",
+  "version": "0.38.0",
   "description": "Hosty app auth: session state machine, recovery bridge, Core revalidation, and the embedder responder.",
   "license": "AGPL-3.0-only",
   "type": "module",
@@ -132,6 +132,22 @@
     "./tool-activity/server": {
       "types": "./dist/tool-activity-server.d.ts",
       "default": "./dist/tool-activity-server.js"
+    },
+    "./tasks": {
+      "types": "./dist/tasks.d.ts",
+      "default": "./dist/tasks.js"
+    },
+    "./tasks/server": {
+      "types": "./dist/tasks-server.d.ts",
+      "default": "./dist/tasks-server.js"
+    },
+    "./feedback": {
+      "types": "./dist/feedback-types.d.ts",
+      "default": "./dist/feedback-types.js"
+    },
+    "./feedback/server": {
+      "types": "./dist/feedback-server.d.ts",
+      "default": "./dist/feedback-server.js"
     }
   },
   "scripts": {

package/dist/sandbox-identity.d.ts

@@ -1,10 +0,0 @@
-export interface SandboxTarget {
-    runtimeInstanceId: string;
-    generation: string;
-    dataRevision: string;
-}
-export interface SandboxIdentityContext extends SandboxTarget {
-    identityRealm: "sandbox" | "core";
-    appRole: string;
-    permissions: string[];
-}

package/dist/sandbox-identity.js

@@ -1 +0,0 @@
-export {};