@agent-native/core 0.161.23 → 0.163.0

package/dist/org/schema.d.ts

@@ -536,3 +536,318 @@ export declare const orgInvitations: import("drizzle-orm/sqlite-core").SQLiteTab
     };
     dialect: 'sqlite';
 }>;
+/** Workspace app access is framework-owned so every mounted app can enforce it. */
+export declare const workspaceApps: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "workspace_apps";
+    schema: undefined;
+    columns: {
+        ownerEmail: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "owner_email";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        orgId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "org_id";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        visibility: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "visibility";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "org" | "private" | "public";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["private", "org", "public"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        description: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "description";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        path: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "path";
+            tableName: "workspace_apps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "workspace_apps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "workspace_apps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'sqlite';
+}>;
+export declare const workspaceAppShares: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        resourceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "resource_id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        principalType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "principal_type";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "group" | "org" | "user";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["user", "group", "org"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        principalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "principal_id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        role: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "role";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "admin" | "commenter" | "editor" | "viewer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["viewer", "commenter", "editor", "admin"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        createdBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_by";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+    };
+    dialect: 'sqlite';
+}>;

package/dist/org/schema.js

@@ -1,4 +1,4 @@
-import { table, text, integer } from "../db/schema.js";
+import { table, text, integer, ownableColumns, createSharesTable, } from "../db/schema.js";
 export const organizations = table("organizations", {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
@@ -39,3 +39,22 @@ export const orgInvitations = table("org_invitations", {
     status: text("status").notNull(),
     role: text("role"),
 });
+/** Workspace app access is framework-owned so every mounted app can enforce it. */
+export const workspaceApps = table("workspace_apps", {
+    id: text("id").primaryKey(),
+    ...ownableColumns(),
+    // Workspace apps are visible to their organization by default. The generic
+    // ownable primitive remains private-by-default for user-created resources;
+    // app creation is a deliberate workspace-level exception.
+    visibility: text("visibility", {
+        enum: ["private", "org", "public"],
+    })
+        .notNull()
+        .default("org"),
+    name: text("name").notNull(),
+    description: text("description"),
+    path: text("path").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+});
+export const workspaceAppShares = createSharesTable("workspace_app_shares");

package/dist/org/types.d.ts

@@ -3,6 +3,7 @@
  */
 export type OrgRole = "owner" | "admin" | "member";
 export type RequiredAuthProvider = "google" | null;
+export type WorkspaceAppDefaultVisibility = "private" | "org";
 export interface OrgContext {
     email: string;
     orgId: string | null;
@@ -43,6 +44,8 @@ export interface OrgInfo {
     workspaceUrl: string | null;
     /** Sign-in provider required for members of the active org. */
     requiredAuthProvider: RequiredAuthProvider;
+    /** Default visibility applied when a new workspace app is first registered. */
+    workspaceAppDefaultVisibility?: WorkspaceAppDefaultVisibility;
     /**
      * Whether the active org has an A2A secret. The value itself is never part
      * of this payload — owners/admins fetch it on demand from

package/dist/org/workspace-app-access.d.ts

@@ -0,0 +1,10 @@
+export interface WorkspaceAppAccessContext {
+    email: string;
+    orgId?: string | null;
+}
+/**
+ * Enforce the workspace-app ACL before a hosted app's authenticated API
+ * surface is reached. The app shell remains cacheable and anonymous; this
+ * check protects the session-backed APIs/actions that make the app useful.
+ */
+export declare function isWorkspaceAppAccessAllowed(appId: string, context: WorkspaceAppAccessContext): Promise<boolean>;

package/dist/org/workspace-app-access.js

@@ -0,0 +1,179 @@
+import { signA2AToken } from "../a2a/client.js";
+import { getAppConfig } from "../app-config/index.js";
+import { getDbExec } from "../db/client.js";
+import { workspaceUserGroupsIncludeUser } from "../workspace-connections/groups.js";
+import { getOrgA2ASecret, getOrgDomain } from "./context.js";
+const WORKSPACE_APPS_ACTION_PATH = "/_agent-native/actions/list-workspace-apps";
+const WORKSPACE_APP_ACCESS_TIMEOUT_MS = 2_500;
+function normalizedEmail(email) {
+    return email.trim().toLowerCase();
+}
+function configuredWorkspaceDirectory() {
+    const workspace = getAppConfig().workspace;
+    return (workspace.orgDirectoryUrl?.trim() || workspace.gatewayUrl?.trim() || null);
+}
+function workspaceAppsActionUrl(base) {
+    try {
+        const baseUrl = new URL(base);
+        if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+            return null;
+        }
+        const basePath = baseUrl.pathname.replace(/\/+$/, "");
+        baseUrl.pathname = `${basePath}${WORKSPACE_APPS_ACTION_PATH}`;
+        baseUrl.search = "";
+        baseUrl.searchParams.set("includeAgentCards", "false");
+        baseUrl.searchParams.set("audience", "all");
+        baseUrl.hash = "";
+        return baseUrl;
+    }
+    catch {
+        // coercion-ok: malformed configured URL is a typed unavailable registry.
+        return null;
+    }
+}
+function workspaceAppsFromResponse(value) {
+    if (Array.isArray(value))
+        return value;
+    if (value &&
+        typeof value === "object" &&
+        Array.isArray(value.apps)) {
+        return value.apps;
+    }
+    return [];
+}
+/**
+ * Hosted app databases are not the authority for workspace-app rows. Ask the
+ * Dispatch registry action, which resolves the ACL against its shared store,
+ * so an app-scoped database cannot accidentally turn a missing local row into
+ * access. A configured registry is fail-closed on every network/auth error.
+ */
+async function hostedWorkspaceAppAccess(appId, context, email) {
+    const configuredDirectory = configuredWorkspaceDirectory();
+    if (!configuredDirectory)
+        return null;
+    const url = workspaceAppsActionUrl(configuredDirectory);
+    if (!url)
+        return false;
+    const orgId = context.orgId?.trim() || null;
+    const [orgDomain, orgSecret] = orgId
+        ? await Promise.all([getOrgDomain(orgId), getOrgA2ASecret(orgId)])
+        : [null, null];
+    let token;
+    try {
+        token = await signA2AToken(email, orgDomain?.trim() || undefined, orgSecret?.trim() || undefined, {
+            expiresIn: "1m",
+            preferGlobalSecret: true,
+            ...(orgId ? { extraClaims: { org_id: orgId } } : {}),
+        });
+    }
+    catch (error) {
+        console.error("[workspace-app-access] registry token unavailable", error);
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), WORKSPACE_APP_ACCESS_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            headers: {
+                accept: "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return false;
+        const apps = workspaceAppsFromResponse(
+        // coercion-ok: malformed registry JSON is an authorization failure.
+        await response.json().catch(() => null));
+        return apps.some((app) => app.id === appId);
+    }
+    catch (error) {
+        console.error("[workspace-app-access] registry access check failed", error);
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Enforce the workspace-app ACL before a hosted app's authenticated API
+ * surface is reached. The app shell remains cacheable and anonymous; this
+ * check protects the session-backed APIs/actions that make the app useful.
+ */
+export async function isWorkspaceAppAccessAllowed(appId, context) {
+    const normalizedAppId = appId.trim();
+    const email = normalizedEmail(context.email);
+    if (!normalizedAppId || normalizedAppId === "dispatch" || !email) {
+        return true;
+    }
+    const hostedAccess = await hostedWorkspaceAppAccess(normalizedAppId, context, email);
+    if (hostedAccess !== null)
+        return hostedAccess;
+    // Standalone/local deployments have no Dispatch registry URL. Keep the
+    // direct lookup for that mode, but never let missing or malformed ACL state
+    // grant access.
+    try {
+        const db = getDbExec();
+        const appResult = await db.execute({
+            sql: `SELECT owner_email, org_id, visibility
+            FROM workspace_apps WHERE id = ? LIMIT 1`,
+            args: [normalizedAppId],
+        });
+        const app = appResult.rows[0];
+        if (!app)
+            return false;
+        const ownerEmail = normalizedEmail(typeof app.owner_email === "string" ? app.owner_email : "");
+        const resourceOrgId = (typeof app.org_id === "string" ? app.org_id : "").trim() || null;
+        const orgId = context.orgId?.trim() || null;
+        const sameOrg = !!resourceOrgId && resourceOrgId === orgId;
+        if (ownerEmail === email && (!resourceOrgId || sameOrg))
+            return true;
+        if (!sameOrg || !orgId)
+            return false;
+        const memberResult = await db.execute({
+            sql: `SELECT role FROM org_members
+            WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
+            args: [orgId, email],
+        });
+        if (memberResult.rows.length === 0)
+            return false;
+        const memberRole = String(memberResult.rows[0]?.role ?? "");
+        if (memberRole === "owner" || memberRole === "admin")
+            return true;
+        if (app.visibility === "org")
+            return true;
+        if (app.visibility !== "private")
+            return false;
+        const userShare = await db.execute({
+            sql: `SELECT 1 FROM workspace_app_shares
+            WHERE resource_id = ? AND principal_type = 'user'
+              AND LOWER(principal_id) = ? LIMIT 1`,
+            args: [normalizedAppId, email],
+        });
+        if (userShare.rows.length > 0)
+            return true;
+        const orgShare = await db.execute({
+            sql: `SELECT 1 FROM workspace_app_shares
+            WHERE resource_id = ? AND principal_type = 'org'
+              AND principal_id = ? LIMIT 1`,
+            args: [normalizedAppId, orgId],
+        });
+        if (orgShare.rows.length > 0)
+            return true;
+        const groupShares = await db.execute({
+            sql: `SELECT principal_id FROM workspace_app_shares
+            WHERE resource_id = ? AND principal_type = 'group'`,
+            args: [normalizedAppId],
+        });
+        const groupIds = groupShares.rows
+            .map((row) => typeof row.principal_id === "string" ? row.principal_id : "")
+            .filter(Boolean);
+        return workspaceUserGroupsIncludeUser(resourceOrgId, groupIds, email);
+    }
+    catch (error) {
+        // Missing migrations, missing rows, and every other DB failure deny
+        // protected app access until the authoritative ACL is available.
+        console.error("[workspace-app-access] access check failed", error);
+        return false;
+    }
+}

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -77,8 +77,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 }, z.core.$strip>>, {
     message?: undefined;
     id?: undefined;
+    provider?: undefined;
     deleted?: undefined;
-    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,7 +89,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
+    found?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
@@ -105,9 +105,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     count?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     providers?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
@@ -115,19 +115,19 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     count?: undefined;
-    found?: undefined;
-    providers?: undefined;
     provider?: undefined;
+    providers?: undefined;
+    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
     count?: undefined;
+    provider?: undefined;
     deleted?: undefined;
-    found?: undefined;
     providers?: undefined;
-    provider?: undefined;
+    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -313,8 +313,6 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     }, {
         id?: undefined;
         deleted?: undefined;
-        provider?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -325,6 +323,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        provider?: undefined;
+        found?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
@@ -340,19 +340,19 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
-        provider?: undefined;
-        found?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
+        found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
@@ -360,10 +360,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         deleted?: undefined;
-        provider?: undefined;
-        found?: undefined;
         providers?: undefined;
         count?: undefined;
+        provider?: undefined;
+        found?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/provider-api/index.d.ts

@@ -286,6 +286,16 @@ export interface ProviderApiConfig {
     accessErrorGuidance?: string;
     corpusRecipes?: readonly ProviderApiCorpusRecipe[];
     templateUses?: readonly WorkspaceConnectionTemplateUse[];
+    /**
+     * Some provider APIs (Slack's Web API is the documented case) answer every
+     * request with HTTP 200 and encode the real outcome as a boolean field in
+     * the JSON body instead. When set, a response with this field explicitly
+     * `false` is treated as a failed request — `response.ok` is flipped to
+     * `false` — so a caller (or the agent) that only checks the transport-level
+     * `ok`, the same signal every other provider uses for success, can't
+     * mistake a rejected send for a delivered one.
+     */
+    bodyOkField?: string;
 }
 export interface ProviderApiPlaceholder {
     name: string;