@pikku/cli 0.11.2 → 0.12.0

package/dist/src/functions/wirings/cli/pikku-command-cli.d.ts

@@ -1 +1 @@
-export declare const pikkuCLI: any;
+export declare const pikkuCLI: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/cli/pikku-command-cli.js

@@ -1,8 +1,9 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuCLI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -10,13 +11,20 @@ export const pikkuCLI = pikkuSessionlessFunc({
         const { cli } = visitState;
         // Generate CLI wirings file
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
-        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(cli.meta, null, 2));
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(cli.meta);
+        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(cli.meta)) {
+            const verbosePath = cliWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(cli.meta, null, 2));
+        }
         const jsonImportPath = getFileImportRelativePath(cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState('cli', 'meta', metaData as CLIMeta)`);
+        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/cli/serialize-channel-cli.js

@@ -12,9 +12,9 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         for (const [name, cmd] of Object.entries(commands)) {
             const fullPath = [...path, name];
             const commandKey = fullPath.join('.');
-            if (cmd.pikkuFuncName) {
+            if (cmd.pikkuFuncId) {
                 commandMap[commandKey] = {
-                    pikkuFuncName: cmd.pikkuFuncName,
+                    pikkuFuncId: cmd.pikkuFuncId,
                 };
             }
             // Recursively process subcommands
@@ -26,13 +26,13 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
     collectCommands(programMeta.commands);
     // Generate imports from function file locations
     const funcNames = [
-        ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
+        ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncId)),
     ];
     const imports = funcNames
-        .map((pikkuFuncName) => {
-        const fileInfo = functionFiles.get(pikkuFuncName);
+        .map((pikkuFuncId) => {
+        const fileInfo = functionFiles.get(pikkuFuncId);
         if (!fileInfo) {
-            throw new Error(`Function not found in files map: ${pikkuFuncName}`);
+            throw new Error(`Function not found in files map: ${pikkuFuncId}`);
         }
         const importPath = getFileImportRelativePath(channelFile, fileInfo.path, packageMappings);
         return `import { ${fileInfo.exportedName} } from '${importPath}'`;
@@ -79,8 +79,8 @@ wireChannel({
   onMessageWiring: {
     command: {
 ${Object.entries(commandMap)
-        .map(([commandKey, { pikkuFuncName }]) => `      '${commandKey}': {
-        func: ${pikkuFuncName},
+        .map(([commandKey, { pikkuFuncId }]) => `      '${commandKey}': {
+        func: ${pikkuFuncId},
         middleware: [cliCloseOnComplete],
       }`)
         .join(',\n')}

package/dist/src/functions/wirings/cli/serialize-cli-types.js

@@ -7,7 +7,7 @@ export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport
  * CLI-specific type definitions for tree-shaking optimization
  */
 
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig, defineCLICommands as defineCLICommandsCore } from '@pikku/core/cli'
 import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -91,5 +91,18 @@ export const pikkuCLICommand = <
 ): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
   return config as any
 }
+
+/**
+ * Type-safe helper for defining CLI commands that can be composed and spread into wireCLI.
+ *
+ * @template T - Record of CLI command configurations
+ * @param commands - The CLI commands record
+ * @returns The same commands record (identity function for type safety)
+ */
+export const defineCLICommands = <T extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>>(
+  commands: T
+): T => {
+  return defineCLICommandsCore(commands as any) as T
+}
 `;
 };

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.d.ts

@@ -5,10 +5,10 @@ import { Config } from '../../../../types/application-types.js';
 export declare function serializeLocalCLIBootstrap(programName: string, _programMeta: any, bootstrapFile: string, config: Config, pikkuConfigFactory: {
     file: string;
     variable: string;
-}, singletonServicesFactory: {
+} | undefined, singletonServicesFactory: {
     file: string;
     variable: string;
-}, wireServicesFactory: {
+}, wireServicesFactory?: {
     file: string;
     variable: string;
 }): string;

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.js

@@ -4,30 +4,29 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
  */
 export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory) {
     const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
-    // Get relative import paths
-    const pikkuConfigPath = getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings);
+    const pikkuConfigPath = pikkuConfigFactory
+        ? getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings)
+        : null;
     const singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
-    const wireServicesPath = getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings);
+    const wireServicesPath = wireServicesFactory
+        ? getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings)
+        : null;
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
 import { executeCLI, CLIError } from '@pikku/core/cli'
-import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
+${pikkuConfigFactory ? `import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'` : ''}
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
+${wireServicesFactory ? `import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'` : ''}
 import '${cliBootstrapPath}'
 
-/**
- * ${capitalizedName} CLI function
- * Handles command line arguments and executes the appropriate function
- */
 export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
   try {
     await executeCLI({
       programName: '${programName}',
       args: args || process.argv.slice(2),
-      createConfig,
+${pikkuConfigFactory ? '      createConfig,' : ''}
       createSingletonServices,
-      createWireServices,
+${wireServicesFactory ? '      createWireServices,' : ''}
     })
   } catch (error) {
     if (error instanceof CLIError) {

package/dist/src/functions/wirings/console/pikku-command-console-functions.d.ts

@@ -0,0 +1 @@
+export declare const pikkuConsoleFunctions: import("#pikku").PikkuFunctionConfig<void, boolean, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/console/pikku-command-console-functions.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeConsoleFunctions } from './serialize-console-functions.js';
+import { join } from 'path';
+export const pikkuConsoleFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.console?.functionsPath) {
+            const consoleFunctionsPath = join(config.rootDir, config.console.functionsPath);
+            const pathToPikkuTypes = getFileImportRelativePath(consoleFunctionsPath, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, consoleFunctionsPath, serializeConsoleFunctions(pathToPikkuTypes));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Console functions',
+            commandEnd: 'Generated Console functions',
+        }),
+    ],
+});

package/dist/src/functions/wirings/console/pikku-command-node-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuNodeTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/console/pikku-command-node-types.js

@@ -0,0 +1,21 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeNodeTypes } from './serialize-node-types.js';
+export const pikkuNodeTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings, node, } = config;
+        let rpcMapImportPath = getFileImportRelativePath(nodeTypesFile, rpcInternalMapDeclarationFile, packageMappings);
+        rpcMapImportPath = rpcMapImportPath.replace('.d.js', '.js');
+        const categories = node?.categories;
+        const content = serializeNodeTypes(rpcMapImportPath, categories);
+        await writeFileInDir(logger, nodeTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Node types',
+            commandEnd: 'Created Node types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.d.ts

@@ -0,0 +1 @@
+export declare const pikkuNodesMeta: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.js

@@ -0,0 +1,79 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { readFile } from 'fs/promises';
+import { join, isAbsolute } from 'path';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+const loadIcon = async (iconPath, rootDir, logger) => {
+    if (!iconPath)
+        return undefined;
+    const fullPath = isAbsolute(iconPath) ? iconPath : join(rootDir, iconPath);
+    try {
+        const content = await readFile(fullPath, 'utf-8');
+        const trimmed = content.trim();
+        if (!trimmed.startsWith('<svg') && !trimmed.startsWith('<?xml')) {
+            logger.warn(`Icon file is not a valid SVG: ${fullPath}`);
+            return undefined;
+        }
+        return trimmed.replace(/<\?xml[^?]*\?>\s*/g, '').trim();
+    }
+    catch (e) {
+        logger.warn(`Could not load icon: ${fullPath}`);
+        return undefined;
+    }
+};
+export const pikkuNodesMeta = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { nodes, secrets } = state;
+        const { nodesMetaJsonFile, node, rootDir } = config;
+        const secretsMeta = validateAndBuildSecretDefinitionsMeta(secrets.definitions, state.schemaLookup);
+        const hasNodes = Object.keys(nodes.meta).length > 0;
+        const hasSecrets = secrets.definitions.length > 0;
+        if (!hasNodes && !hasSecrets) {
+            return undefined;
+        }
+        const allowedCategories = node?.categories;
+        if (allowedCategories && allowedCategories.length > 0) {
+            for (const [name, meta] of Object.entries(nodes.meta)) {
+                if (!allowedCategories.includes(meta.category)) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `Node '${name}' has invalid category '${meta.category}'. ` +
+                        `Allowed categories: ${allowedCategories.join(', ')}`);
+                }
+            }
+        }
+        const outputMeta = {};
+        for (const [name, meta] of Object.entries(nodes.meta)) {
+            const { icon: _icon, ...nodeMetaWithoutIcon } = meta;
+            outputMeta[name] = nodeMetaWithoutIcon;
+        }
+        const packageIcon = await loadIcon(node?.icon, rootDir, logger);
+        const metaData = {
+            nodes: outputMeta,
+            secrets: secretsMeta,
+            package: {
+                displayName: node?.displayName,
+                description: node?.description,
+                icon: packageIcon,
+                categories: node?.categories,
+            },
+        };
+        if (nodesMetaJsonFile) {
+            const minimalMeta = stripVerboseFields(metaData);
+            await writeFileInDir(logger, nodesMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+            if (hasVerboseFields(metaData)) {
+                const verbosePath = nodesMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+                await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating nodes metadata',
+            commandEnd: 'Generated nodes metadata',
+        }),
+    ],
+});

package/dist/src/functions/wirings/console/serialize-console-functions.d.ts

@@ -0,0 +1 @@
+export declare const serializeConsoleFunctions: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -0,0 +1,229 @@
+export const serializeConsoleFunctions = (pathToPikkuTypes) => {
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, external } from '${pathToPikkuTypes}'
+import { streamAIAgent, resumeAIAgent } from '@pikku/core/ai-agent'
+import type { AIStreamChannel } from '@pikku/core/ai-agent'
+
+export const streamAgentRun = pikkuSessionlessFunc<
+  { agentName: string; message: string; threadId: string; resourceId?: string },
+  any
+>({
+  title: 'Stream Agent Run',
+  description: 'SSE stream of agent conversation responses.',
+  expose: false,
+  auth: false,
+  func: async (services, data, { channel }) => {
+    if (!channel) return
+    await streamAIAgent(
+      data.agentName,
+      {
+        message: data.message,
+        threadId: data.threadId,
+        resourceId: data.resourceId || 'console-playground',
+      },
+      channel as unknown as AIStreamChannel,
+      { singletonServices: services }
+    )
+  },
+})
+
+export const resumeAgentRun = pikkuSessionlessFunc<
+  {
+    agentName: string
+    toolCallId: string
+    approved: boolean
+  },
+  any
+>({
+  title: 'Resume Agent Run',
+  description: 'Resume an agent run after tool approval/denial.',
+  expose: false,
+  auth: false,
+  func: async (services, data, { channel }) => {
+    if (!channel) return
+    await resumeAIAgent(
+      {
+        toolCallId: data.toolCallId,
+        approved: data.approved,
+      },
+      channel as unknown as AIStreamChannel,
+      { singletonServices: services }
+    )
+  },
+})
+
+export interface SetSecretInput {
+  secretId: string
+  value: unknown
+}
+
+export interface SetSecretOutput {
+  success: boolean
+}
+
+export const setSecret = pikkuSessionlessFunc<SetSecretInput, SetSecretOutput>({
+  description: 'Set the value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId, value }) => {
+    await secrets.setSecretJSON(secretId, value)
+    return { success: true }
+  },
+})
+
+export interface GetVariableInput {
+  variableId: string
+}
+
+export interface GetVariableOutput {
+  exists: boolean
+  value: unknown | null
+}
+
+export const getVariable = pikkuSessionlessFunc<
+  GetVariableInput,
+  GetVariableOutput
+>({
+  description: 'Get the current value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId }) => {
+    const exists = await variables.has(variableId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    try {
+      const value = await variables.getJSON(variableId)
+      return { exists: true, value }
+    } catch {
+      const value = await variables.get(variableId)
+      return { exists: true, value }
+    }
+  },
+})
+
+export interface SetVariableInput {
+  variableId: string
+  value: unknown
+}
+
+export interface SetVariableOutput {
+  success: boolean
+}
+
+export const setVariable = pikkuSessionlessFunc<
+  SetVariableInput,
+  SetVariableOutput
+>({
+  description: 'Set the value of a variable',
+  expose: true,
+  auth: false,
+  func: async ({ variables }, { variableId, value }) => {
+    if (typeof value === 'string') {
+      await variables.set(variableId, value)
+    } else {
+      await variables.setJSON(variableId, value)
+    }
+    return { success: true }
+  },
+})
+
+export interface GetSecretInput {
+  secretId: string
+}
+
+export interface GetSecretOutput {
+  exists: boolean
+  value: unknown | null
+}
+
+export const getSecret = pikkuSessionlessFunc<
+  GetSecretInput,
+  GetSecretOutput
+>({
+  description: 'Get the current value of a secret',
+  expose: true,
+  auth: false,
+  func: async ({ secrets }, { secretId }) => {
+    const exists = await secrets.hasSecret(secretId)
+    if (!exists) {
+      return { exists: false, value: null }
+    }
+    const value = await secrets.getSecretJSON(secretId)
+    return { exists: true, value }
+  },
+})
+
+export interface StartWorkflowRunInput {
+  workflowName: string
+  input?: any
+}
+
+export interface StartWorkflowRunOutput {
+  runId: string
+}
+
+export const startWorkflowRun = pikkuSessionlessFunc<
+  StartWorkflowRunInput,
+  StartWorkflowRunOutput
+>({
+  title: 'Start Workflow Run',
+  description: 'Starts a new workflow run by name with optional input.',
+  expose: true,
+  auth: false,
+  func: async (_services, { workflowName, input }, { rpc }) => {
+    return await (rpc as any).startWorkflow(workflowName, input || {})
+  },
+})
+
+export const consoleRoutes = defineHTTPRoutes({
+  auth: false,
+  routes: {
+    externalIconOptions: {
+      route: '/external/icon/:alias',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ alias: string }>(async () => void 0),
+    },
+    externalIcon: {
+      route: '/external/icon/:alias',
+      method: 'get',
+      func: external('console:getExternalIcon'),
+    },
+    agentStreamOptions: {
+      route: '/api/agents/:agentName/stream',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+    },
+    agentStream: {
+      route: '/api/agents/:agentName/stream',
+      method: 'post',
+      sse: true,
+      func: streamAgentRun,
+    },
+    agentResumeOptions: {
+      route: '/api/agents/:agentName/resume',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+    },
+    agentResume: {
+      route: '/api/agents/:agentName/resume',
+      method: 'post',
+      sse: true,
+      func: resumeAgentRun,
+    },
+    workflowRunStreamOptions: {
+      route: '/api/workflow-run/:runId/stream',
+      method: 'options',
+      func: pikkuSessionlessFunc<{ runId: string }>(async () => void 0),
+    },
+    workflowRunStream: {
+      route: '/api/workflow-run/:runId/stream',
+      method: 'get',
+      sse: true,
+      func: external('console:streamWorkflowRun'),
+    },
+  },
+})
+
+wireHTTPRoutes({ routes: { console: consoleRoutes } })
+`;
+};

package/dist/src/functions/wirings/console/serialize-node-types.d.ts

@@ -0,0 +1 @@
+export declare const serializeNodeTypes: (rpcMapImportPath: string, categories: string[] | undefined) => string;

package/dist/src/functions/wirings/console/serialize-node-types.js

@@ -0,0 +1,11 @@
+export const serializeNodeTypes = (rpcMapImportPath, categories) => {
+    const categoryType = categories?.length
+        ? categories.map((c) => `'${c}'`).join(' | ')
+        : 'never';
+    return `import type { FlattenedRPCMap } from '${rpcMapImportPath}'
+
+export type NodeCategory = ${categoryType}
+
+export type NodeRPCName = keyof FlattenedRPCMap
+`;
+};

package/dist/src/functions/wirings/functions/pikku-command-external-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuExternalTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-external-types.js

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeExternalTypes } from './serialize-external-types.js';
+export const pikkuExternalTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        if (!config.externalPackage) {
+            return;
+        }
+        const visitState = await getInspectorState();
+        const { externalTypesFile, packageMappings, servicesFile, secretsFile, variablesFile, } = config;
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            singletonServicesType: true,
+        });
+        const { singletonServicesType, pikkuConfigType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(externalTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeExternalTypes(`import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(externalTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, configTypeImport, `import type { RequiredSingletonServices } from '${getFileImportRelativePath(externalTypesFile, servicesFile, packageMappings)}'`, `import { TypedSecretService } from '${getFileImportRelativePath(externalTypesFile, secretsFile, packageMappings)}'`, `import { TypedVariablesService } from '${getFileImportRelativePath(externalTypesFile, variablesFile, packageMappings)}'`);
+        await writeFileInDir(logger, externalTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating external types',
+            commandEnd: 'Created external types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctionTypesSplit: any;
+export declare const pikkuFunctionTypesSplit: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
@@ -21,7 +21,7 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName, undefined, config.node?.categories);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/pikku-command-function-types.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctionTypes: any;
+export declare const pikkuFunctionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-function-types.js

@@ -1,12 +1,17 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, triggersTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, nodeTypesFile, secretTypesFile, externalTypesFile, } = config;
+        const getImportPath = (file) => config.externalPackage
+            ? null
+            : getFileImportRelativePath(typesFile, file, packageMappings);
+        // Node and trigger types are included for external packages
+        const getAlwaysImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getAlwaysImportPath(triggersTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getAlwaysImportPath(nodeTypesFile), getAlwaysImportPath(secretTypesFile), config.externalPackage ? getAlwaysImportPath(externalTypesFile) : null);
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/pikku-command-functions.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctions: any;
+export declare const pikkuFunctions: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;