@pikku/cli 0.11.2 → 0.11.3

package/.pikku/channel/pikku-channel-types.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
 
@@ -9,6 +9,12 @@
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
 import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '../function/pikku-function-types.gen.js'
+import type { ZodLike, CorePermissionGroup } from '@pikku/core'
+
+/**
+ * Helper type to infer the output type from a Zod schema
+ */
+type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -59,21 +65,72 @@ export const pikkuChannelDisconnectionFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for channel functions with Zod schema validation.
+ */
+type PikkuChannelFuncConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    'channel' | 'session' | 'rpc'
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a function that handles WebSocket channel messages.
  * Called when a message is received on a channel.
- * This is the same as pikkuSessionlessFunc but with ChannelData = unknown by default.
  *
- * @template In - Input type for channel messages
- * @template Out - Output type for channel responses
+ * Supports two patterns:
+ * 1. Generic types: `pikkuChannelFunc<Input, Output>({ func: ... })`
+ * 2. Zod schemas: `pikkuChannelFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for channel messages (inferred from schema if provided)
+ * @template Out - Output type for channel responses (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
+ *
+ * @example
+ * ```typescript
+ * // Pattern 1: Using generic types
+ * const handleMessage = pikkuChannelFunc<{text: string}, {received: boolean}>({
+ *   func: async (_services, { text }) => ({ received: true })
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const messageInput = z.object({ text: z.string() })
+ * const messageOutput = z.object({ received: z.boolean() })
+ *
+ * const handleMessage = pikkuChannelFunc({
+ *   input: messageInput,
+ *   output: messageOutput,
+ *   func: async (_services, { text }) => ({ received: true })
+ * })
+ * ```
  */
-export const pikkuChannelFunc = <In, Out = unknown>(
+export function pikkuChannelFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuChannelFuncConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
+export function pikkuChannelFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
+export function pikkuChannelFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 

package/.pikku/channel/pikku-channels-map.gen.d.ts

@@ -1,14 +1,12 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
  * This provides the structure needed for TypeScript to be aware of channels
  */
-    
 
 
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
+
 export type PikkuSchemasOutput = false | true
 export type PikkuFunctionsOutput = false | true
 export type PikkuMiddlewareOutput = false | true
@@ -23,6 +21,8 @@ export type PikkuQueueOutput = false | true
 export type PikkuChannelsOutput = false | true
 export type PikkuMCPOutput = false | true
 export type PikkuCLIOutput = false | true
+export type PikkuPackageOutput = false | true
+export type PikkuForgeNodesOutput = false | true
 
 interface ChannelHandler<I, O> {
     input: I;

package/.pikku/channel/pikku-channels-meta.gen.ts

@@ -1,5 +1,7 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 import { pikkuState } from '@pikku/core'
-pikkuState('channel', 'meta', {})
+import type { ChannelsMeta } from '@pikku/core/channel'
+import metaData from './pikku-channels-meta.gen.json' with { type: 'json' }
+pikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)

package/.pikku/channel/pikku-channels.gen.ts

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /* The files with an addChannel function call */

package/.pikku/cli/pikku-cli-channel.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
  * WebSocket channel backend for 'pikku' CLI commands

package/.pikku/cli/pikku-cli-client.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 
 import { executeCLIViaChannel } from '@pikku/core/cli/channel'

package/.pikku/cli/pikku-cli-types.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
 

package/.pikku/cli/pikku-cli-wirings-meta.gen.json

@@ -135,12 +135,13 @@
           "jwt",
           "config",
           "variables",
+          "secrets",
           "workflowService",
           "queueService",
           "schedulerService"
         ]
       },
-      "filePath": "src/services.ts"
+      "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"
     }
   }
 }

package/.pikku/cli/pikku-cli-wirings-meta.gen.ts

@@ -1,7 +1,7 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 import { pikkuState } from '@pikku/core'
 import { CLIMeta } from '@pikku/core/cli'
 import metaData from './pikku-cli-wirings-meta.gen.json' with { type: 'json' }
-pikkuState('cli', 'meta', metaData as CLIMeta)
+pikkuState(null, 'cli', 'meta', metaData as CLIMeta)

package/.pikku/cli/pikku-cli-wirings.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /* The files with an wireCLI function call */
 import '../../src/cli.wiring.js'

package/.pikku/cli/pikku-cli.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 
 import { executeCLI, CLIError } from '@pikku/core/cli'

package/.pikku/forge/pikku-forge-types.gen.ts

@@ -0,0 +1,83 @@
+/**
+ * This file was generated by @pikku/cli@0.11.3
+ */
+/**
+ * Forge-specific type definitions for typed wireForgeNode and wireForgeCredential
+ */
+
+import { wireForgeNode as wireForgeNodeCore, wireForgeCredential as wireForgeCredentialCore } from '@pikku/core/forge-node'
+import type { CoreForgeNode, CoreForgeCredential } from '@pikku/core/forge-node'
+import type { FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.js'
+
+/**
+ * Valid category values for forge nodes.
+ * No categories configured - wireForgeNode cannot be used until forge.node.categories is defined in pikku.config.json.
+ */
+export type ForgeCategory = never
+
+/**
+ * Valid RPC names that can be used with forge nodes.
+ * These are derived from the FlattenedRPCMap which includes both local and external package RPCs.
+ */
+export type ForgeRPCName = keyof FlattenedRPCMap
+
+/**
+ * Typed forge node configuration.
+ * Validates that category and rpc are valid values.
+ */
+export type TypedForgeNode = Omit<CoreForgeNode, 'category' | 'rpc'> & {
+  /** Grouping category (validated against forge.node.categories in config) */
+  category: ForgeCategory
+  /** RPC name to call when node executes (must be a valid RPC name) */
+  rpc: ForgeRPCName
+}
+
+/**
+ * Registers a Forge node with validated category and RPC.
+ *
+ * @param config - Forge node configuration with typed category and rpc
+ *
+ * @example
+ * ```typescript
+ * wireForgeNode({
+ *   name: 'send-email',
+ *   displayName: 'Send Email',
+ *   category: 'Communication', // Must be in forge.node.categories
+ *   type: 'action',
+ *   rpc: 'sendEmail', // Must be a valid RPC name
+ *   description: 'Sends an email to a recipient'
+ * })
+ * ```
+ */
+export const wireForgeNode = (config: TypedForgeNode): void => {
+  wireForgeNodeCore(config as CoreForgeNode)
+}
+
+/**
+ * Registers a Forge credential definition.
+ * Credentials define secrets/API keys required by the package.
+ *
+ * @template T - Zod schema type for the credential structure
+ * @param config - Forge credential configuration
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ *
+ * const apiCredentials = z.object({
+ *   apiKey: z.string().describe('API key for authentication'),
+ *   apiSecret: z.string().describe('API secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'example-api',
+ *   displayName: 'Example API Credentials',
+ *   description: 'Credentials for the example external API',
+ *   secretId: 'EXAMPLE_API_CREDENTIALS',
+ *   schema: apiCredentials
+ * })
+ * ```
+ */
+export const wireForgeCredential = <T>(config: CoreForgeCredential<T>): void => {
+  wireForgeCredentialCore(config)
+}

package/.pikku/function/pikku-function-types.gen.ts

@@ -1,18 +1,18 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.11.3
  */
 /**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 
 import type { UserSession } from '../../types/application-types.d.js'
 import type { SingletonServices } from '../../types/application-types.d.js'
 import type { Services } from '../../types/application-types.d.js'
 import type { Config } from '../../types/application-types.d.js'
-import type { TypedPikkuRPC } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+import type { TypedPikkuRPC, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
 import type { RequiredSingletonServices, RequiredWireServices } from '../pikku-services.gen.js'
 
 
@@ -207,6 +207,11 @@ export type PikkuFunction<
     PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
   >
 
+/**
+ * Helper type to infer the output type from a Zod schema
+ */
+export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
+
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
  * This type wraps CorePikkuFunctionConfig with the user's custom types.
@@ -219,64 +224,166 @@ export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
   RequiredWires extends keyof PikkuWire = never,
-  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>
-> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>,
+  InputSchema extends ZodLike | undefined = undefined,
+  OutputSchema extends ZodLike | undefined = undefined
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
+
+/**
+ * Configuration object for Pikku functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuFunctionConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunction<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  > | PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
 
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: `pikkuFunc<Input, Output>({ func: ... })`
+ * 2. Zod schemas: `pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input, wire) => {
- *     const session = await wire.session.get()
- *     logger.info('Creating user', input.name)
+ * ```typescript
+ * // Pattern 1: Using generic types
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
+ *   func: async ({db}, input) => {
  *     const user = await db.users.create(input)
- *     return {id: user.id, message: \`User \${input.name} created successfully\`}
- *   },
- *   auth: true
+ *     return { id: user.id }
+ *   }
  * })
- * \`\`\`
+ *
+ * // Pattern 2: Using Zod schemas (types inferred automatically)
+ * const createUserInput = z.object({ name: z.string(), email: z.string() })
+ * const createUserOutput = z.object({ id: z.number() })
+ *
+ * const createUser = pikkuFunc({
+ *   input: createUserInput,
+ *   output: createUserOutput,
+ *   func: async ({db}, input) => {
+ *     // input is typed as { name: string, email: string }
+ *     const user = await db.users.create(input)
+ *     return { id: user.id } // must match output schema
+ *   }
+ * })
+ * ```
  */
-export const pikkuFunc = <In, Out = unknown>(
+export function pikkuFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuFunc<In, Out = unknown>(
   func:
     | PikkuFunction<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for sessionless Pikku functions with Zod schema validation.
+ */
+export type PikkuFunctionSessionlessConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  description?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: `pikkuSessionlessFunc<Input, Output>({ func: ... })`
+ * 2. Zod schemas: `pikkuSessionlessFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}, input) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
+ * ```typescript
+ * // Pattern 1: Using generic types
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
+ *   func: async ({logger}) => {
+ *     return { status: 'healthy' }
+ *   }
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const greetInput = z.object({ name: z.string() })
+ * const greetOutput = z.object({ message: z.string() })
+ *
+ * const greet = pikkuSessionlessFunc({
+ *   input: greetInput,
+ *   output: greetOutput,
+ *   func: async (_services, { name }) => {
+ *     return { message: `Hello, ${name}!` }
+ *   }
  * })
- * \`\`\`
+ * ```
  */
-export const pikkuSessionlessFunc = <In, Out = unknown>(
+export function pikkuSessionlessFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuSessionlessFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -288,13 +395,13 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
+ * ```typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \`\`\`
+ * ```
  */
 export const pikkuVoidFunc = (
   func:
@@ -304,6 +411,45 @@ export const pikkuVoidFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a wrapper function for external package functions that are exposed via RPC.
+ * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * without type compatibility issues.
+ *
+ * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
+ * @param rpcName - The name of the RPC method to invoke
+ * @returns A Pikku function that proxies calls to the external RPC method
+ *
+ * @example
+ * ```typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * ```
+ */
+export const external = <Name extends keyof FlattenedRPCMap>(
+  rpcName: Name
+): PikkuFunctionConfig<
+  FlattenedRPCMap[Name]['input'],
+  FlattenedRPCMap[Name]['output'],
+  'session' | 'rpc'
+> => {
+  return {
+    func: (async (_services: any, data: any, { rpc }: any) => {
+      return rpc.invoke(rpcName, data)
+    }) as any
+  } as PikkuFunctionConfig<
+    FlattenedRPCMap[Name]['input'],
+    FlattenedRPCMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -369,7 +515,7 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-) => func
+): CreateWireServices => func as unknown as CreateWireServices
 
 /**
  * Adds global middleware for a specific tag.
@@ -395,7 +541,7 @@ export const pikkuWireServices = (
  * ```
  */
 export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
-  addMiddlewareCore(tag, middleware as any)
+  addMiddlewareCore(tag, middleware as any, null)
 }
 
 /**
@@ -422,5 +568,5 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * ```
  */
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
-  addPermissionCore(tag, permissions as any)
+  addPermissionCore(tag, permissions as any, null)
 }