@webiny/api-aco 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/features/ai/DeleteFolderTool.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { GetFolderUseCase } from "../folder/GetFolder/index.js";
+import { DeleteFolderUseCase } from "../folder/DeleteFolder/index.js";
+import { NotifyFolderChangeUseCase } from "./NotifyFolderChange/index.js";
+const inputSchema = z.object({
+    folderId: z.string().describe("Folder id as returned by listFolders."),
+    title: z.string().describe("The folder's current title, exactly as listFolders returned it. The delete is refused if it does not match.")
+});
+class DeleteFolderToolHandlerImpl {
+    constructor(getFolder, deleteFolder, notifyFolderChange){
+        this.getFolder = getFolder;
+        this.deleteFolder = deleteFolder;
+        this.notifyFolderChange = notifyFolderChange;
+    }
+    async execute(input) {
+        const found = await this.getFolder.execute(input.folderId);
+        if (found.isFail()) throw new Error(`Folder "${input.folderId}" not found: ${found.error.message}. Call listFolders for valid ids.`);
+        const folder = found.value;
+        if (folder.title !== input.title) throw new Error(`Folder "${input.folderId}" is titled "${folder.title}", not "${input.title}", so nothing was deleted. Check the folder with listFolders.`);
+        const result = await this.deleteFolder.execute(folder.id);
+        if (result.isFail()) throw new Error(`Could not delete the folder: ${result.error.message}`);
+        await this.notifyFolderChange.execute({
+            id: folder.id,
+            change: "deleted"
+        });
+        return {
+            id: folder.id,
+            title: folder.title,
+            path: folder.path,
+            type: folder.type
+        };
+    }
+}
+const DeleteFolderToolHandler = AiSdkToolHandler.createImplementation({
+    implementation: DeleteFolderToolHandlerImpl,
+    dependencies: [
+        GetFolderUseCase,
+        DeleteFolderUseCase,
+        NotifyFolderChangeUseCase
+    ]
+});
+class DeleteFolderToolImpl {
+    constructor(){
+        this.name = "deleteFolder";
+        this.title = "Delete folder";
+        this.description = "Deletes one empty folder. Folders that still contain subfolders or content are refused. Call listFolders first for the id and exact title. Requires user approval.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: false,
+            destructiveHint: true
+        };
+        this.handler = DeleteFolderToolHandler;
+    }
+}
+const DeleteFolderTool = AiSdkToolDefinition.createImplementation({
+    implementation: DeleteFolderToolImpl,
+    dependencies: []
+});
+export { DeleteFolderTool };
+
+//# sourceMappingURL=DeleteFolderTool.js.map

package/features/ai/DeleteFolderTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/DeleteFolderTool.js","sources":["../../../src/features/ai/DeleteFolderTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkToolDefinition, AiSdkToolHandler } from \"@webiny/api-core/features/ai/index.js\";\nimport { GetFolderUseCase } from \"~/features/folder/GetFolder/index.js\";\nimport { DeleteFolderUseCase } from \"~/features/folder/DeleteFolder/index.js\";\nimport { NotifyFolderChangeUseCase } from \"./NotifyFolderChange/index.js\";\n\nconst inputSchema = z.object({\n    folderId: z.string().describe(\"Folder id as returned by listFolders.\"),\n    title: z\n        .string()\n        .describe(\n            \"The folder's current title, exactly as listFolders returned it. The delete is refused if it does not match.\"\n        )\n});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface DeletedFolder {\n    id: string;\n    title: string;\n    path: string;\n    type: string;\n}\n\n/*\n * The title is part of the input so the approval shows the user which folder goes, rather than only\n * an id. The model supplies it, so it is checked against the stored folder before anything is\n * deleted: what the user approved by name has to be the folder that is removed.\n */\nclass DeleteFolderToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {\n    constructor(\n        private getFolder: GetFolderUseCase.Interface,\n        private deleteFolder: DeleteFolderUseCase.Interface,\n        private notifyFolderChange: NotifyFolderChangeUseCase.Interface\n    ) {}\n\n    async execute(input: Input): Promise<DeletedFolder> {\n        const found = await this.getFolder.execute(input.folderId);\n\n        if (found.isFail()) {\n            throw new Error(\n                `Folder \"${input.folderId}\" not found: ${found.error.message}. Call listFolders for valid ids.`\n            );\n        }\n\n        const folder = found.value;\n\n        if (folder.title !== input.title) {\n            throw new Error(\n                `Folder \"${input.folderId}\" is titled \"${folder.title}\", not \"${input.title}\", so nothing was deleted. Check the folder with listFolders.`\n            );\n        }\n\n        const result = await this.deleteFolder.execute(folder.id);\n\n        if (result.isFail()) {\n            throw new Error(`Could not delete the folder: ${result.error.message}`);\n        }\n\n        await this.notifyFolderChange.execute({ id: folder.id, change: \"deleted\" });\n\n        return { id: folder.id, title: folder.title, path: folder.path, type: folder.type };\n    }\n}\n\nconst DeleteFolderToolHandler = AiSdkToolHandler.createImplementation({\n    implementation: DeleteFolderToolHandlerImpl,\n    dependencies: [GetFolderUseCase, DeleteFolderUseCase, NotifyFolderChangeUseCase]\n});\n\n/**\n * Deletes one folder.\n *\n * Destructive, so the approval says it cannot be undone. Only an empty folder can go: the folder\n * feature refuses to delete one that still holds subfolders or content, and that error reaches the\n * model as-is.\n */\nclass DeleteFolderToolImpl implements AiSdkToolDefinition.Interface<Input> {\n    readonly name = \"deleteFolder\";\n    readonly title = \"Delete folder\";\n    readonly description =\n        \"Deletes one empty folder. Folders that still contain subfolders or content are refused. Call listFolders first for the id and exact title. Requires user approval.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: false, destructiveHint: true };\n    readonly handler = DeleteFolderToolHandler;\n}\n\nexport const DeleteFolderTool = AiSdkToolDefinition.createImplementation({\n    implementation: DeleteFolderToolImpl,\n    dependencies: []\n});\n"],"names":["inputSchema","z","DeleteFolderToolHandlerImpl","getFolder","deleteFolder","notifyFolderChange","input","found","Error","folder","result","DeleteFolderToolHandler","AiSdkToolHandler","GetFolderUseCase","DeleteFolderUseCase","NotifyFolderChangeUseCase","DeleteFolderToolImpl","DeleteFolderTool","AiSdkToolDefinition"],"mappings":";;;;;AAMA,MAAMA,cAAcC,EAAE,MAAM,CAAC;IACzB,UAAUA,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC9B,OAAOA,EAAAA,MACI,GACN,QAAQ,CACL;AAEZ;AAgBA,MAAMC;IACF,YACYC,SAAqC,EACrCC,YAA2C,EAC3CC,kBAAuD,CACjE;aAHUF,SAAS,GAATA;aACAC,YAAY,GAAZA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QAAQC,KAAY,EAA0B;QAChD,MAAMC,QAAQ,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD,MAAM,QAAQ;QAEzD,IAAIC,MAAM,MAAM,IACZ,MAAM,IAAIC,MACN,CAAC,QAAQ,EAAEF,MAAM,QAAQ,CAAC,aAAa,EAAEC,MAAM,KAAK,CAAC,OAAO,CAAC,iCAAiC,CAAC;QAIvG,MAAME,SAASF,MAAM,KAAK;QAE1B,IAAIE,OAAO,KAAK,KAAKH,MAAM,KAAK,EAC5B,MAAM,IAAIE,MACN,CAAC,QAAQ,EAAEF,MAAM,QAAQ,CAAC,aAAa,EAAEG,OAAO,KAAK,CAAC,QAAQ,EAAEH,MAAM,KAAK,CAAC,6DAA6D,CAAC;QAIlJ,MAAMI,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD,OAAO,EAAE;QAExD,IAAIC,OAAO,MAAM,IACb,MAAM,IAAIF,MAAM,CAAC,6BAA6B,EAAEE,OAAO,KAAK,CAAC,OAAO,EAAE;QAG1E,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAAE,IAAID,OAAO,EAAE;YAAE,QAAQ;QAAU;QAEzE,OAAO;YAAE,IAAIA,OAAO,EAAE;YAAE,OAAOA,OAAO,KAAK;YAAE,MAAMA,OAAO,IAAI;YAAE,MAAMA,OAAO,IAAI;QAAC;IACtF;AACJ;AAEA,MAAME,0BAA0BC,iBAAiB,oBAAoB,CAAC;IAClE,gBAAgBV;IAChB,cAAc;QAACW;QAAkBC;QAAqBC;KAA0B;AACpF;AASA,MAAMC;;aACO,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGhB;aACd,WAAW,GAAG;YAAE,cAAc;YAAO,iBAAiB;QAAK;aAC3D,OAAO,GAAGW;;AACvB;AAEO,MAAMM,mBAAmBC,oBAAoB,oBAAoB,CAAC;IACrE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/ai/GrantFolderAccessTool.d.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { UpdateFolderUseCase } from "../../features/folder/UpdateFolder/index.js";
+import { NotifyFolderChangeUseCase } from "./NotifyFolderChange/index.js";
+declare const inputSchema: z.ZodObject<{
+    folderId: z.ZodString;
+    target: z.ZodString;
+    level: z.ZodEnum<{
+        editor: "editor";
+        "no-access": "no-access";
+        owner: "owner";
+        public: "public";
+        viewer: "viewer";
+    }>;
+}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface GrantResult {
+    folderId: string;
+    title: string;
+    path: string;
+    /**
+     * Every direct rule on the folder afterwards.
+     *
+     * This is the set the update was asked to store, not an independent read of it:
+     * `UpdateFolderWithFolderLevelPermissions` returns the permissions it derived from the input
+     * rather than the ones the repository wrote. Treating it as a verification would let the tool
+     * confirm its own request back to itself.
+     */
+    permissions: {
+        target: string;
+        level: string;
+    }[];
+    /** True when the target already had a direct rule and its level was changed. */
+    replacedExistingLevel?: string;
+}
+declare class GrantFolderAccessToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {
+    private getFolder;
+    private updateFolder;
+    private listTeams;
+    private notifyFolderChange;
+    constructor(getFolder: GetFolderUseCase.Interface, updateFolder: UpdateFolderUseCase.Interface, listTeams: ListTeamsUseCase.Interface, notifyFolderChange: NotifyFolderChangeUseCase.Interface);
+    execute(input: Input): Promise<GrantResult>;
+}
+/**
+ * Grants one target access to one folder, leaving every other rule alone.
+ *
+ * Additive by design. The earlier tool took the complete permission set and replaced it, which meant
+ * approving a change showed what would be SET and said nothing about what would be removed — a rule
+ * the model omitted disappeared silently. One target per call keeps the approval honest: what the user
+ * sees in the plan is the whole change.
+ */
+declare class GrantFolderAccessToolImpl implements AiSdkToolDefinition.Interface<Input> {
+    readonly name = "grantFolderAccess";
+    readonly title = "Grant folder access";
+    readonly description = "Grants one team or user a level of access on one folder, leaving all other permissions untouched. Use listFolders for the folder id and listTeams for a team slug. Requires user approval.";
+    readonly inputSchema: z.ZodObject<{
+        folderId: z.ZodString;
+        target: z.ZodString;
+        level: z.ZodEnum<{
+            editor: "editor";
+            "no-access": "no-access";
+            owner: "owner";
+            public: "public";
+            viewer: "viewer";
+        }>;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+    };
+    readonly handler: typeof GrantFolderAccessToolHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions.js").IAiSdkToolHandler<any>>;
+    };
+}
+export declare const GrantFolderAccessTool: typeof GrantFolderAccessToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions.js").IAiSdkToolDefinition<any>>;
+};
+export {};

package/features/ai/GrantFolderAccessTool.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+import { GetFolderUseCase } from "../folder/GetFolder/index.js";
+import { UpdateFolderUseCase } from "../folder/UpdateFolder/index.js";
+import { loadFolderPermissions } from "./loadFolderPermissions.js";
+import { assertTargetIsUsable } from "./assertTargetIsUsable.js";
+import { NotifyFolderChangeUseCase } from "./NotifyFolderChange/index.js";
+const ACCESS_LEVELS = [
+    "owner",
+    "editor",
+    "viewer",
+    "public",
+    "no-access"
+];
+const inputSchema = z.object({
+    folderId: z.string().describe("Folder id as returned by listFolders."),
+    target: z.string().describe("Who to grant access to. A team is 'team:<slug>' — the SLUG, not the id. A user is 'admin:<userId>'. Resolve with listTeams first."),
+    level: z["enum"](ACCESS_LEVELS).describe("owner = full control including permissions; editor = change content; viewer = read only; no-access = explicitly denied.")
+});
+class GrantFolderAccessToolHandlerImpl {
+    constructor(getFolder, updateFolder, listTeams, notifyFolderChange){
+        this.getFolder = getFolder;
+        this.updateFolder = updateFolder;
+        this.listTeams = listTeams;
+        this.notifyFolderChange = notifyFolderChange;
+    }
+    async execute(input) {
+        const loaded = await loadFolderPermissions(this.getFolder, input.folderId);
+        await assertTargetIsUsable(this.listTeams, input.target, loaded.inheritedTargets);
+        const existing = loaded.direct.find((permission)=>String(permission.target) === input.target);
+        const permissions = loaded.direct.filter((permission)=>String(permission.target) !== input.target).concat([
+            {
+                target: input.target,
+                level: input.level
+            }
+        ]);
+        const result = await this.updateFolder.execute(input.folderId, {
+            permissions
+        });
+        if (result.isFail()) throw new Error(`Could not grant access: ${result.error.message}`);
+        const folder = result.value;
+        await this.notifyFolderChange.execute({
+            id: folder.id,
+            change: "updated"
+        });
+        const granted = {
+            folderId: folder.id,
+            title: folder.title,
+            path: folder.path,
+            permissions: (folder.permissions ?? []).filter((permission)=>!permission.inheritedFrom).map((permission)=>({
+                    target: String(permission.target),
+                    level: permission.level
+                }))
+        };
+        if (existing) granted.replacedExistingLevel = existing.level;
+        return granted;
+    }
+}
+const GrantFolderAccessToolHandler = AiSdkToolHandler.createImplementation({
+    implementation: GrantFolderAccessToolHandlerImpl,
+    dependencies: [
+        GetFolderUseCase,
+        UpdateFolderUseCase,
+        ListTeamsUseCase,
+        NotifyFolderChangeUseCase
+    ]
+});
+class GrantFolderAccessToolImpl {
+    constructor(){
+        this.name = "grantFolderAccess";
+        this.title = "Grant folder access";
+        this.description = "Grants one team or user a level of access on one folder, leaving all other permissions untouched. Use listFolders for the folder id and listTeams for a team slug. Requires user approval.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: false
+        };
+        this.handler = GrantFolderAccessToolHandler;
+    }
+}
+const GrantFolderAccessTool = AiSdkToolDefinition.createImplementation({
+    implementation: GrantFolderAccessToolImpl,
+    dependencies: []
+});
+export { GrantFolderAccessTool };
+
+//# sourceMappingURL=GrantFolderAccessTool.js.map

package/features/ai/GrantFolderAccessTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/GrantFolderAccessTool.js","sources":["../../../src/features/ai/GrantFolderAccessTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkToolDefinition, AiSdkToolHandler } from \"@webiny/api-core/features/ai/index.js\";\nimport { ListTeamsUseCase } from \"@webiny/api-core/features/security/teams/ListTeams/index.js\";\nimport { GetFolderUseCase } from \"~/features/folder/GetFolder/index.js\";\nimport { UpdateFolderUseCase } from \"~/features/folder/UpdateFolder/index.js\";\nimport type { FolderPermission } from \"~/types.js\";\nimport { loadFolderPermissions } from \"./loadFolderPermissions.js\";\nimport { assertTargetIsUsable } from \"./assertTargetIsUsable.js\";\nimport { NotifyFolderChangeUseCase } from \"./NotifyFolderChange/index.js\";\n\nconst ACCESS_LEVELS = [\"owner\", \"editor\", \"viewer\", \"public\", \"no-access\"] as const;\n\nconst inputSchema = z.object({\n    folderId: z.string().describe(\"Folder id as returned by listFolders.\"),\n    target: z\n        .string()\n        .describe(\n            \"Who to grant access to. A team is 'team:<slug>' — the SLUG, not the id. A user is 'admin:<userId>'. Resolve with listTeams first.\"\n        ),\n    level: z\n        .enum(ACCESS_LEVELS)\n        .describe(\n            \"owner = full control including permissions; editor = change content; viewer = read only; no-access = explicitly denied.\"\n        )\n});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface GrantResult {\n    folderId: string;\n    title: string;\n    path: string;\n    /**\n     * Every direct rule on the folder afterwards.\n     *\n     * This is the set the update was asked to store, not an independent read of it:\n     * `UpdateFolderWithFolderLevelPermissions` returns the permissions it derived from the input\n     * rather than the ones the repository wrote. Treating it as a verification would let the tool\n     * confirm its own request back to itself.\n     */\n    permissions: { target: string; level: string }[];\n    /** True when the target already had a direct rule and its level was changed. */\n    replacedExistingLevel?: string;\n}\n\nclass GrantFolderAccessToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {\n    constructor(\n        private getFolder: GetFolderUseCase.Interface,\n        private updateFolder: UpdateFolderUseCase.Interface,\n        private listTeams: ListTeamsUseCase.Interface,\n        private notifyFolderChange: NotifyFolderChangeUseCase.Interface\n    ) {}\n\n    async execute(input: Input): Promise<GrantResult> {\n        const loaded = await loadFolderPermissions(this.getFolder, input.folderId);\n\n        await assertTargetIsUsable(this.listTeams, input.target, loaded.inheritedTargets);\n\n        const existing = loaded.direct.find(\n            permission => String(permission.target) === input.target\n        );\n\n        const permissions: FolderPermission[] = loaded.direct\n            .filter(permission => String(permission.target) !== input.target)\n            .concat([{ target: input.target, level: input.level } as FolderPermission]);\n\n        const result = await this.updateFolder.execute(input.folderId, { permissions });\n\n        if (result.isFail()) {\n            throw new Error(`Could not grant access: ${result.error.message}`);\n        }\n\n        const folder = result.value;\n\n        await this.notifyFolderChange.execute({ id: folder.id, change: \"updated\" });\n\n        const granted: GrantResult = {\n            folderId: folder.id,\n            title: folder.title,\n            path: folder.path,\n            permissions: (folder.permissions ?? [])\n                .filter(permission => !permission.inheritedFrom)\n                .map(permission => ({ target: String(permission.target), level: permission.level }))\n        };\n\n        if (existing) {\n            granted.replacedExistingLevel = existing.level;\n        }\n\n        return granted;\n    }\n}\n\nconst GrantFolderAccessToolHandler = AiSdkToolHandler.createImplementation({\n    implementation: GrantFolderAccessToolHandlerImpl,\n    dependencies: [\n        GetFolderUseCase,\n        UpdateFolderUseCase,\n        ListTeamsUseCase,\n        NotifyFolderChangeUseCase\n    ]\n});\n\n/**\n * Grants one target access to one folder, leaving every other rule alone.\n *\n * Additive by design. The earlier tool took the complete permission set and replaced it, which meant\n * approving a change showed what would be SET and said nothing about what would be removed — a rule\n * the model omitted disappeared silently. One target per call keeps the approval honest: what the user\n * sees in the plan is the whole change.\n */\nclass GrantFolderAccessToolImpl implements AiSdkToolDefinition.Interface<Input> {\n    readonly name = \"grantFolderAccess\";\n    readonly title = \"Grant folder access\";\n    readonly description =\n        \"Grants one team or user a level of access on one folder, leaving all other permissions untouched. Use listFolders for the folder id and listTeams for a team slug. Requires user approval.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: false };\n    readonly handler = GrantFolderAccessToolHandler;\n}\n\nexport const GrantFolderAccessTool = AiSdkToolDefinition.createImplementation({\n    implementation: GrantFolderAccessToolImpl,\n    dependencies: []\n});\n"],"names":["ACCESS_LEVELS","inputSchema","z","GrantFolderAccessToolHandlerImpl","getFolder","updateFolder","listTeams","notifyFolderChange","input","loaded","loadFolderPermissions","assertTargetIsUsable","existing","permission","String","permissions","result","Error","folder","granted","GrantFolderAccessToolHandler","AiSdkToolHandler","GetFolderUseCase","UpdateFolderUseCase","ListTeamsUseCase","NotifyFolderChangeUseCase","GrantFolderAccessToolImpl","GrantFolderAccessTool","AiSdkToolDefinition"],"mappings":";;;;;;;;AAUA,MAAMA,gBAAgB;IAAC;IAAS;IAAU;IAAU;IAAU;CAAY;AAE1E,MAAMC,cAAcC,EAAE,MAAM,CAAC;IACzB,UAAUA,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC9B,QAAQA,EAAAA,MACG,GACN,QAAQ,CACL;IAER,OAAOA,CAAC,CAADA,OACE,CAACF,eACL,QAAQ,CACL;AAEZ;AAqBA,MAAMG;IACF,YACYC,SAAqC,EACrCC,YAA2C,EAC3CC,SAAqC,EACrCC,kBAAuD,CACjE;aAJUH,SAAS,GAATA;aACAC,YAAY,GAAZA;aACAC,SAAS,GAATA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QAAQC,KAAY,EAAwB;QAC9C,MAAMC,SAAS,MAAMC,sBAAsB,IAAI,CAAC,SAAS,EAAEF,MAAM,QAAQ;QAEzE,MAAMG,qBAAqB,IAAI,CAAC,SAAS,EAAEH,MAAM,MAAM,EAAEC,OAAO,gBAAgB;QAEhF,MAAMG,WAAWH,OAAO,MAAM,CAAC,IAAI,CAC/BI,CAAAA,aAAcC,OAAOD,WAAW,MAAM,MAAML,MAAM,MAAM;QAG5D,MAAMO,cAAkCN,OAAO,MAAM,CAChD,MAAM,CAACI,CAAAA,aAAcC,OAAOD,WAAW,MAAM,MAAML,MAAM,MAAM,EAC/D,MAAM,CAAC;YAAC;gBAAE,QAAQA,MAAM,MAAM;gBAAE,OAAOA,MAAM,KAAK;YAAC;SAAsB;QAE9E,MAAMQ,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACR,MAAM,QAAQ,EAAE;YAAEO;QAAY;QAE7E,IAAIC,OAAO,MAAM,IACb,MAAM,IAAIC,MAAM,CAAC,wBAAwB,EAAED,OAAO,KAAK,CAAC,OAAO,EAAE;QAGrE,MAAME,SAASF,OAAO,KAAK;QAE3B,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAAE,IAAIE,OAAO,EAAE;YAAE,QAAQ;QAAU;QAEzE,MAAMC,UAAuB;YACzB,UAAUD,OAAO,EAAE;YACnB,OAAOA,OAAO,KAAK;YACnB,MAAMA,OAAO,IAAI;YACjB,aAAcA,AAAAA,CAAAA,OAAO,WAAW,IAAI,EAAC,EAChC,MAAM,CAACL,CAAAA,aAAc,CAACA,WAAW,aAAa,EAC9C,GAAG,CAACA,CAAAA,aAAe;oBAAE,QAAQC,OAAOD,WAAW,MAAM;oBAAG,OAAOA,WAAW,KAAK;gBAAC;QACzF;QAEA,IAAID,UACAO,QAAQ,qBAAqB,GAAGP,SAAS,KAAK;QAGlD,OAAOO;IACX;AACJ;AAEA,MAAMC,+BAA+BC,iBAAiB,oBAAoB,CAAC;IACvE,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;KACH;AACL;AAUA,MAAMC;;aACO,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGzB;aACd,WAAW,GAAG;YAAE,cAAc;QAAM;aACpC,OAAO,GAAGmB;;AACvB;AAEO,MAAMO,wBAAwBC,oBAAoB,oBAAoB,CAAC;IAC1E,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/ai/ListFoldersTool.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListFoldersUseCase } from "../../features/folder/ListFolders/index.js";
+declare const inputSchema: z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface FolderSummary {
+    id: string;
+    title: string;
+    slug: string;
+    path: string;
+    parentId?: string | null;
+    permissions: {
+        target: string;
+        level: string;
+        inherited: boolean;
+    }[];
+}
+declare class ListFoldersToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {
+    private listFolders;
+    constructor(listFolders: ListFoldersUseCase.Interface);
+    execute(input: Input): Promise<FolderSummary[]>;
+}
+/**
+ * Lists folders with their current access rules, so a permission change is proposed against a real
+ * folder id and the user can see what the access already is before approving a change to it.
+ */
+declare class ListFoldersToolImpl implements AiSdkToolDefinition.Interface<Input> {
+    readonly name = "listFolders";
+    readonly title = "List folders";
+    readonly description = "Lists folders of a given type with their ids, paths and current access permissions. Call this before changing folder permissions so the change targets a real folder.";
+    readonly inputSchema: z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+    readonly handler: typeof ListFoldersToolHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolHandler<any>>;
+    };
+}
+export declare const ListFoldersTool: typeof ListFoldersToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolDefinition<any>>;
+};
+export {};

package/features/ai/ListFoldersTool.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListFoldersUseCase } from "../folder/ListFolders/index.js";
+const inputSchema = z.object({
+    type: z.string().describe("Folder namespace, e.g. 'FmFile' for the file manager or 'cms:<modelId>' for a content model's folders.")
+});
+class ListFoldersToolHandlerImpl {
+    constructor(listFolders){
+        this.listFolders = listFolders;
+    }
+    async execute(input) {
+        const result = await this.listFolders.execute({
+            where: {
+                type: input.type
+            }
+        });
+        if (result.isFail()) throw new Error(`Could not list folders: ${result.error.message}`);
+        return result.value.folders.map((folder)=>({
+                id: folder.id,
+                title: folder.title,
+                slug: folder.slug,
+                path: folder.path,
+                parentId: folder.parentId,
+                permissions: (folder.permissions ?? []).map((permission)=>({
+                        target: permission.target,
+                        level: permission.level,
+                        inherited: Boolean(permission.inheritedFrom)
+                    }))
+            }));
+    }
+}
+const ListFoldersToolHandler = AiSdkToolHandler.createImplementation({
+    implementation: ListFoldersToolHandlerImpl,
+    dependencies: [
+        ListFoldersUseCase
+    ]
+});
+class ListFoldersToolImpl {
+    constructor(){
+        this.name = "listFolders";
+        this.title = "List folders";
+        this.description = "Lists folders of a given type with their ids, paths and current access permissions. Call this before changing folder permissions so the change targets a real folder.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: true,
+            idempotentHint: true
+        };
+        this.handler = ListFoldersToolHandler;
+    }
+}
+const ListFoldersTool = AiSdkToolDefinition.createImplementation({
+    implementation: ListFoldersToolImpl,
+    dependencies: []
+});
+export { ListFoldersTool };
+
+//# sourceMappingURL=ListFoldersTool.js.map

package/features/ai/ListFoldersTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/ListFoldersTool.js","sources":["../../../src/features/ai/ListFoldersTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkToolDefinition, AiSdkToolHandler } from \"@webiny/api-core/features/ai/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\n\nconst inputSchema = z.object({\n    type: z\n        .string()\n        .describe(\n            \"Folder namespace, e.g. 'FmFile' for the file manager or 'cms:<modelId>' for a content model's folders.\"\n        )\n});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface FolderSummary {\n    id: string;\n    title: string;\n    slug: string;\n    path: string;\n    parentId?: string | null;\n    permissions: { target: string; level: string; inherited: boolean }[];\n}\n\nclass ListFoldersToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {\n    constructor(private listFolders: ListFoldersUseCase.Interface) {}\n\n    async execute(input: Input): Promise<FolderSummary[]> {\n        const result = await this.listFolders.execute({ where: { type: input.type } });\n\n        if (result.isFail()) {\n            throw new Error(`Could not list folders: ${result.error.message}`);\n        }\n\n        return result.value.folders.map(folder => ({\n            id: folder.id,\n            title: folder.title,\n            slug: folder.slug,\n            path: folder.path,\n            parentId: folder.parentId,\n            permissions: (folder.permissions ?? []).map(permission => ({\n                target: permission.target,\n                level: permission.level,\n                // Inherited rules cannot be edited on this folder — only on the ancestor that set them.\n                inherited: Boolean(permission.inheritedFrom)\n            }))\n        }));\n    }\n}\n\nconst ListFoldersToolHandler = AiSdkToolHandler.createImplementation({\n    implementation: ListFoldersToolHandlerImpl,\n    dependencies: [ListFoldersUseCase]\n});\n\n/**\n * Lists folders with their current access rules, so a permission change is proposed against a real\n * folder id and the user can see what the access already is before approving a change to it.\n */\nclass ListFoldersToolImpl implements AiSdkToolDefinition.Interface<Input> {\n    readonly name = \"listFolders\";\n    readonly title = \"List folders\";\n    readonly description =\n        \"Lists folders of a given type with their ids, paths and current access permissions. Call this before changing folder permissions so the change targets a real folder.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: true, idempotentHint: true };\n    readonly handler = ListFoldersToolHandler;\n}\n\nexport const ListFoldersTool = AiSdkToolDefinition.createImplementation({\n    implementation: ListFoldersToolImpl,\n    dependencies: []\n});\n"],"names":["inputSchema","z","ListFoldersToolHandlerImpl","listFolders","input","result","Error","folder","permission","Boolean","ListFoldersToolHandler","AiSdkToolHandler","ListFoldersUseCase","ListFoldersToolImpl","ListFoldersTool","AiSdkToolDefinition"],"mappings":";;;AAIA,MAAMA,cAAcC,EAAE,MAAM,CAAC;IACzB,MAAMA,EAAAA,MACK,GACN,QAAQ,CACL;AAEZ;AAaA,MAAMC;IACF,YAAoBC,WAAyC,CAAE;aAA3CA,WAAW,GAAXA;IAA4C;IAEhE,MAAM,QAAQC,KAAY,EAA4B;QAClD,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAAE,OAAO;gBAAE,MAAMD,MAAM,IAAI;YAAC;QAAE;QAE5E,IAAIC,OAAO,MAAM,IACb,MAAM,IAAIC,MAAM,CAAC,wBAAwB,EAAED,OAAO,KAAK,CAAC,OAAO,EAAE;QAGrE,OAAOA,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAACE,CAAAA,SAAW;gBACvC,IAAIA,OAAO,EAAE;gBACb,OAAOA,OAAO,KAAK;gBACnB,MAAMA,OAAO,IAAI;gBACjB,MAAMA,OAAO,IAAI;gBACjB,UAAUA,OAAO,QAAQ;gBACzB,aAAcA,AAAAA,CAAAA,OAAO,WAAW,IAAI,EAAC,EAAG,GAAG,CAACC,CAAAA,aAAe;wBACvD,QAAQA,WAAW,MAAM;wBACzB,OAAOA,WAAW,KAAK;wBAEvB,WAAWC,QAAQD,WAAW,aAAa;oBAC/C;YACJ;IACJ;AACJ;AAEA,MAAME,yBAAyBC,iBAAiB,oBAAoB,CAAC;IACjE,gBAAgBT;IAChB,cAAc;QAACU;KAAmB;AACtC;AAMA,MAAMC;;aACO,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGb;aACd,WAAW,GAAG;YAAE,cAAc;YAAM,gBAAgB;QAAK;aACzD,OAAO,GAAGU;;AACvB;AAEO,MAAMI,kBAAkBC,oBAAoB,oBAAoB,CAAC;IACpE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/ai/ListRolesTool.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListRolesUseCase } from "@webiny/api-core/features/security/roles/ListRoles/index.js";
+interface RoleSummary {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+}
+declare class ListRolesToolHandlerImpl implements AiSdkToolHandler.Interface<Record<string, never>> {
+    private listRoles;
+    constructor(listRoles: ListRolesUseCase.Interface);
+    execute(): Promise<RoleSummary[]>;
+}
+/**
+ * Resolves role names to the IDs `createTeam` takes. Separate from the write, so the user approves a
+ * team with roles that were looked up rather than guessed.
+ *
+ * Returns the slug too, because it is what a human recognises and what the admin UI shows, while
+ * `id` is what a team actually stores. Nothing at the type level separates the two, so `createTeam`
+ * accepts either and resolves it rather than making the caller guess which one that field wants.
+ */
+declare class ListRolesToolImpl implements AiSdkToolDefinition.Interface<Record<string, never>> {
+    readonly name = "listRoles";
+    readonly title = "List roles";
+    readonly description = "Lists the security roles in this project. Call this before createTeam and pass the `id` of each role you want. A slug also works, but a value that is neither is rejected.";
+    readonly inputSchema: z.ZodObject<{}, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+    readonly handler: typeof ListRolesToolHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolHandler<any>>;
+    };
+}
+export declare const ListRolesTool: typeof ListRolesToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolDefinition<any>>;
+};
+export {};

package/features/ai/ListRolesTool.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListRolesUseCase } from "@webiny/api-core/features/security/roles/ListRoles/index.js";
+const inputSchema = z.object({});
+class ListRolesToolHandlerImpl {
+    constructor(listRoles){
+        this.listRoles = listRoles;
+    }
+    async execute() {
+        const result = await this.listRoles.execute();
+        if (result.isFail()) throw new Error(`Could not list roles: ${result.error.message}`);
+        return result.value.map((role)=>{
+            const summary = {
+                id: role.id,
+                name: role.name,
+                slug: role.slug
+            };
+            if (role.description) summary.description = role.description;
+            return summary;
+        });
+    }
+}
+const ListRolesToolHandler = AiSdkToolHandler.createImplementation({
+    implementation: ListRolesToolHandlerImpl,
+    dependencies: [
+        ListRolesUseCase
+    ]
+});
+class ListRolesToolImpl {
+    constructor(){
+        this.name = "listRoles";
+        this.title = "List roles";
+        this.description = "Lists the security roles in this project. Call this before createTeam and pass the `id` of each role you want. A slug also works, but a value that is neither is rejected.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: true,
+            idempotentHint: true
+        };
+        this.handler = ListRolesToolHandler;
+    }
+}
+const ListRolesTool = AiSdkToolDefinition.createImplementation({
+    implementation: ListRolesToolImpl,
+    dependencies: []
+});
+export { ListRolesTool };
+
+//# sourceMappingURL=ListRolesTool.js.map

package/features/ai/ListRolesTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/ListRolesTool.js","sources":["../../../src/features/ai/ListRolesTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkToolDefinition, AiSdkToolHandler } from \"@webiny/api-core/features/ai/index.js\";\nimport { ListRolesUseCase } from \"@webiny/api-core/features/security/roles/ListRoles/index.js\";\n\nconst inputSchema = z.object({});\n\ninterface RoleSummary {\n    id: string;\n    name: string;\n    slug: string;\n    description?: string;\n}\n\nclass ListRolesToolHandlerImpl implements AiSdkToolHandler.Interface<Record<string, never>> {\n    constructor(private listRoles: ListRolesUseCase.Interface) {}\n\n    async execute(): Promise<RoleSummary[]> {\n        const result = await this.listRoles.execute();\n\n        if (result.isFail()) {\n            throw new Error(`Could not list roles: ${result.error.message}`);\n        }\n\n        return result.value.map(role => {\n            const summary: RoleSummary = {\n                id: role.id,\n                name: role.name,\n                slug: role.slug\n            };\n\n            if (role.description) {\n                summary.description = role.description;\n            }\n\n            return summary;\n        });\n    }\n}\n\nconst ListRolesToolHandler = AiSdkToolHandler.createImplementation({\n    implementation: ListRolesToolHandlerImpl,\n    dependencies: [ListRolesUseCase]\n});\n\n/**\n * Resolves role names to the IDs `createTeam` takes. Separate from the write, so the user approves a\n * team with roles that were looked up rather than guessed.\n *\n * Returns the slug too, because it is what a human recognises and what the admin UI shows, while\n * `id` is what a team actually stores. Nothing at the type level separates the two, so `createTeam`\n * accepts either and resolves it rather than making the caller guess which one that field wants.\n */\nclass ListRolesToolImpl implements AiSdkToolDefinition.Interface<Record<string, never>> {\n    readonly name = \"listRoles\";\n    readonly title = \"List roles\";\n    readonly description =\n        \"Lists the security roles in this project. Call this before createTeam and pass the `id` of each role you want. A slug also works, but a value that is neither is rejected.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: true, idempotentHint: true };\n    readonly handler = ListRolesToolHandler;\n}\n\nexport const ListRolesTool = AiSdkToolDefinition.createImplementation({\n    implementation: ListRolesToolImpl,\n    dependencies: []\n});\n"],"names":["inputSchema","z","ListRolesToolHandlerImpl","listRoles","result","Error","role","summary","ListRolesToolHandler","AiSdkToolHandler","ListRolesUseCase","ListRolesToolImpl","ListRolesTool","AiSdkToolDefinition"],"mappings":";;;AAIA,MAAMA,cAAcC,EAAE,MAAM,CAAC,CAAC;AAS9B,MAAMC;IACF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;IAAwC;IAE5D,MAAM,UAAkC;QACpC,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO;QAE3C,IAAIA,OAAO,MAAM,IACb,MAAM,IAAIC,MAAM,CAAC,sBAAsB,EAAED,OAAO,KAAK,CAAC,OAAO,EAAE;QAGnE,OAAOA,OAAO,KAAK,CAAC,GAAG,CAACE,CAAAA;YACpB,MAAMC,UAAuB;gBACzB,IAAID,KAAK,EAAE;gBACX,MAAMA,KAAK,IAAI;gBACf,MAAMA,KAAK,IAAI;YACnB;YAEA,IAAIA,KAAK,WAAW,EAChBC,QAAQ,WAAW,GAAGD,KAAK,WAAW;YAG1C,OAAOC;QACX;IACJ;AACJ;AAEA,MAAMC,uBAAuBC,iBAAiB,oBAAoB,CAAC;IAC/D,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC;AAUA,MAAMC;;aACO,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGX;aACd,WAAW,GAAG;YAAE,cAAc;YAAM,gBAAgB;QAAK;aACzD,OAAO,GAAGQ;;AACvB;AAEO,MAAMI,gBAAgBC,oBAAoB,oBAAoB,CAAC;IAClE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/ai/ListTeamsTool.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+declare const inputSchema: z.ZodObject<{}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface TeamSummary {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+}
+declare class ListTeamsToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {
+    private listTeams;
+    constructor(listTeams: ListTeamsUseCase.Interface);
+    execute(): Promise<TeamSummary[]>;
+}
+/**
+ * Resolves human names ("team A") to the ids folder permissions actually take.
+ *
+ * Kept separate from setFolderPermissions rather than accepting a team name there: the user approves
+ * the arguments of a write, so the id has to be looked up and shown, not guessed inside the write.
+ */
+declare class ListTeamsToolImpl implements AiSdkToolDefinition.Interface<Input> {
+    readonly name = "listTeams";
+    readonly title = "List teams";
+    readonly description = "Lists the teams in this project with their ids, names and slugs. Folder permission targets use the SLUG (`team:<slug>`), not the id.";
+    readonly inputSchema: z.ZodObject<{}, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+    readonly handler: typeof ListTeamsToolHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolHandler<any>>;
+    };
+}
+export declare const ListTeamsTool: typeof ListTeamsToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/ai/abstractions").IAiSdkToolDefinition<any>>;
+};
+export {};

package/features/ai/ListTeamsTool.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { AiSdkToolDefinition, AiSdkToolHandler } from "@webiny/api-core/features/ai/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+const inputSchema = z.object({});
+class ListTeamsToolHandlerImpl {
+    constructor(listTeams){
+        this.listTeams = listTeams;
+    }
+    async execute() {
+        const result = await this.listTeams.execute();
+        if (result.isFail()) throw new Error(`Could not list teams: ${result.error.message}`);
+        return result.value.map((team)=>{
+            const summary = {
+                id: team.id,
+                name: team.name,
+                slug: team.slug
+            };
+            if (team.description) summary.description = team.description;
+            return summary;
+        });
+    }
+}
+const ListTeamsToolHandler = AiSdkToolHandler.createImplementation({
+    implementation: ListTeamsToolHandlerImpl,
+    dependencies: [
+        ListTeamsUseCase
+    ]
+});
+class ListTeamsToolImpl {
+    constructor(){
+        this.name = "listTeams";
+        this.title = "List teams";
+        this.description = "Lists the teams in this project with their ids, names and slugs. Folder permission targets use the SLUG (`team:<slug>`), not the id.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: true,
+            idempotentHint: true
+        };
+        this.handler = ListTeamsToolHandler;
+    }
+}
+const ListTeamsTool = AiSdkToolDefinition.createImplementation({
+    implementation: ListTeamsToolImpl,
+    dependencies: []
+});
+export { ListTeamsTool };
+
+//# sourceMappingURL=ListTeamsTool.js.map

package/features/ai/ListTeamsTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/ListTeamsTool.js","sources":["../../../src/features/ai/ListTeamsTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkToolDefinition, AiSdkToolHandler } from \"@webiny/api-core/features/ai/index.js\";\nimport { ListTeamsUseCase } from \"@webiny/api-core/features/security/teams/ListTeams/index.js\";\n\nconst inputSchema = z.object({});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface TeamSummary {\n    id: string;\n    name: string;\n    slug: string;\n    description?: string;\n}\n\nclass ListTeamsToolHandlerImpl implements AiSdkToolHandler.Interface<Input> {\n    constructor(private listTeams: ListTeamsUseCase.Interface) {}\n\n    async execute(): Promise<TeamSummary[]> {\n        const result = await this.listTeams.execute();\n\n        if (result.isFail()) {\n            throw new Error(`Could not list teams: ${result.error.message}`);\n        }\n\n        return result.value.map(team => {\n            const summary: TeamSummary = {\n                id: team.id,\n                name: team.name,\n                slug: team.slug\n            };\n\n            if (team.description) {\n                summary.description = team.description;\n            }\n\n            return summary;\n        });\n    }\n}\n\nconst ListTeamsToolHandler = AiSdkToolHandler.createImplementation({\n    implementation: ListTeamsToolHandlerImpl,\n    dependencies: [ListTeamsUseCase]\n});\n\n/**\n * Resolves human names (\"team A\") to the ids folder permissions actually take.\n *\n * Kept separate from setFolderPermissions rather than accepting a team name there: the user approves\n * the arguments of a write, so the id has to be looked up and shown, not guessed inside the write.\n */\nclass ListTeamsToolImpl implements AiSdkToolDefinition.Interface<Input> {\n    readonly name = \"listTeams\";\n    readonly title = \"List teams\";\n    readonly description =\n        \"Lists the teams in this project with their ids, names and slugs. Folder permission targets use the SLUG (`team:<slug>`), not the id.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: true, idempotentHint: true };\n    readonly handler = ListTeamsToolHandler;\n}\n\nexport const ListTeamsTool = AiSdkToolDefinition.createImplementation({\n    implementation: ListTeamsToolImpl,\n    dependencies: []\n});\n"],"names":["inputSchema","z","ListTeamsToolHandlerImpl","listTeams","result","Error","team","summary","ListTeamsToolHandler","AiSdkToolHandler","ListTeamsUseCase","ListTeamsToolImpl","ListTeamsTool","AiSdkToolDefinition"],"mappings":";;;AAIA,MAAMA,cAAcC,EAAE,MAAM,CAAC,CAAC;AAW9B,MAAMC;IACF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;IAAwC;IAE5D,MAAM,UAAkC;QACpC,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO;QAE3C,IAAIA,OAAO,MAAM,IACb,MAAM,IAAIC,MAAM,CAAC,sBAAsB,EAAED,OAAO,KAAK,CAAC,OAAO,EAAE;QAGnE,OAAOA,OAAO,KAAK,CAAC,GAAG,CAACE,CAAAA;YACpB,MAAMC,UAAuB;gBACzB,IAAID,KAAK,EAAE;gBACX,MAAMA,KAAK,IAAI;gBACf,MAAMA,KAAK,IAAI;YACnB;YAEA,IAAIA,KAAK,WAAW,EAChBC,QAAQ,WAAW,GAAGD,KAAK,WAAW;YAG1C,OAAOC;QACX;IACJ;AACJ;AAEA,MAAMC,uBAAuBC,iBAAiB,oBAAoB,CAAC;IAC/D,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC;AAQA,MAAMC;;aACO,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGX;aACd,WAAW,GAAG;YAAE,cAAc;YAAM,gBAAgB;QAAK;aACzD,OAAO,GAAGQ;;AACvB;AAEO,MAAMI,gBAAgBC,oBAAoB,oBAAoB,CAAC;IAClE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/ai/NotifyFolderChange/NotifyFolderChangeUseCase.d.ts

@@ -0,0 +1,11 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/exports/api.js";
+import { NotifyFolderChangeUseCase as UseCaseAbstraction } from "./abstractions.js";
+declare class NotifyFolderChangeUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private sendToIdentity;
+    constructor(identityContext: IdentityContext.Interface, sendToIdentity: WebsocketsSendToIdentityUseCase.Interface);
+    execute({ id, change }: UseCaseAbstraction.Params): Promise<void>;
+}
+export declare const NotifyFolderChangeUseCase: import("@webiny/di").Implementation<typeof NotifyFolderChangeUseCaseImpl>;
+export {};

package/features/ai/NotifyFolderChange/NotifyFolderChangeUseCase.js

@@ -0,0 +1,37 @@
+import { createImplementation } from "@webiny/di";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/exports/api.js";
+import { FOLDER_CREATED_WEBSOCKET_ACTION, FOLDER_DELETED_WEBSOCKET_ACTION, FOLDER_UPDATED_WEBSOCKET_ACTION, NotifyFolderChangeUseCase } from "./abstractions.js";
+const ACTIONS = {
+    created: FOLDER_CREATED_WEBSOCKET_ACTION,
+    updated: FOLDER_UPDATED_WEBSOCKET_ACTION,
+    deleted: FOLDER_DELETED_WEBSOCKET_ACTION
+};
+class NotifyFolderChangeUseCaseImpl {
+    constructor(identityContext, sendToIdentity){
+        this.identityContext = identityContext;
+        this.sendToIdentity = sendToIdentity;
+    }
+    async execute({ id, change }) {
+        const identity = this.identityContext.getIdentity();
+        await this.sendToIdentity.execute({
+            id: identity.id
+        }, {
+            action: ACTIONS[change],
+            data: {
+                id
+            }
+        });
+    }
+}
+const NotifyFolderChangeUseCase_NotifyFolderChangeUseCase = createImplementation({
+    abstraction: NotifyFolderChangeUseCase,
+    implementation: NotifyFolderChangeUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        WebsocketsSendToIdentityUseCase
+    ]
+});
+export { NotifyFolderChangeUseCase_NotifyFolderChangeUseCase as NotifyFolderChangeUseCase };
+
+//# sourceMappingURL=NotifyFolderChangeUseCase.js.map

package/features/ai/NotifyFolderChange/NotifyFolderChangeUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/NotifyFolderChange/NotifyFolderChangeUseCase.js","sources":["../../../../src/features/ai/NotifyFolderChange/NotifyFolderChangeUseCase.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { WebsocketsSendToIdentityUseCase } from \"@webiny/api-websockets/exports/api.js\";\nimport {\n    FOLDER_CREATED_WEBSOCKET_ACTION,\n    FOLDER_DELETED_WEBSOCKET_ACTION,\n    FOLDER_UPDATED_WEBSOCKET_ACTION,\n    NotifyFolderChangeUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\n\nconst ACTIONS: Record<UseCaseAbstraction.Params[\"change\"], string> = {\n    created: FOLDER_CREATED_WEBSOCKET_ACTION,\n    updated: FOLDER_UPDATED_WEBSOCKET_ACTION,\n    deleted: FOLDER_DELETED_WEBSOCKET_ACTION\n};\n\n/*\n * The change is already saved whether or not the message goes out, so the send's result is not the\n * caller's result. When it fails, the admin shows the change after its next reload, as it did before.\n */\nclass NotifyFolderChangeUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private sendToIdentity: WebsocketsSendToIdentityUseCase.Interface\n    ) {}\n\n    async execute({ id, change }: UseCaseAbstraction.Params): Promise<void> {\n        const identity = this.identityContext.getIdentity();\n        await this.sendToIdentity.execute(\n            { id: identity.id },\n            { action: ACTIONS[change], data: { id } }\n        );\n    }\n}\n\nexport const NotifyFolderChangeUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: NotifyFolderChangeUseCaseImpl,\n    dependencies: [IdentityContext, WebsocketsSendToIdentityUseCase]\n});\n"],"names":["ACTIONS","FOLDER_CREATED_WEBSOCKET_ACTION","FOLDER_UPDATED_WEBSOCKET_ACTION","FOLDER_DELETED_WEBSOCKET_ACTION","NotifyFolderChangeUseCaseImpl","identityContext","sendToIdentity","id","change","identity","NotifyFolderChangeUseCase","createImplementation","UseCaseAbstraction","IdentityContext","WebsocketsSendToIdentityUseCase"],"mappings":";;;;AAUA,MAAMA,UAA+D;IACjE,SAASC;IACT,SAASC;IACT,SAASC;AACb;AAMA,MAAMC;IACF,YACYC,eAA0C,EAC1CC,cAAyD,CACnE;aAFUD,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQ,EAAEC,EAAE,EAAEC,MAAM,EAA6B,EAAiB;QACpE,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B;YAAE,IAAIA,SAAS,EAAE;QAAC,GAClB;YAAE,QAAQT,OAAO,CAACQ,OAAO;YAAE,MAAM;gBAAED;YAAG;QAAE;IAEhD;AACJ;AAEO,MAAMG,sDAA4BC,qBAAqB;IAC1D,aAAaC;IACb,gBAAgBR;IAChB,cAAc;QAACS;QAAiBC;KAAgC;AACpE"}