@pikku/cli 0.11.3 → 0.12.1

package/dist/src/functions/commands/new-function.js

@@ -0,0 +1,79 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+export const pikkuNewFunction = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'sessionless' }) => {
+        const filePath = scaffoldFilePath(config, 'functions', name, '.functions.ts', config.scaffold?.functionDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        const inputName = capitalize(name) + 'Input';
+        const outputName = capitalize(name) + 'Output';
+        let content;
+        switch (type) {
+            case 'func':
+                content = `import { pikkuFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export type ${outputName} = {
+  // TODO: define output
+}
+
+export const ${name} = pikkuFunc<${inputName}, ${outputName}>({
+  func: async ({ logger }, data, { session }) => {
+    // TODO: implement
+    return {} as ${outputName}
+  },
+})
+`;
+                break;
+            case 'void':
+                content = `import { pikkuVoidFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export const ${name} = pikkuVoidFunc<${inputName}>({
+  func: async ({ logger }, data) => {
+    // TODO: implement
+  },
+})
+`;
+                break;
+            case 'sessionless':
+            default:
+                content = `import { pikkuSessionlessFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export type ${outputName} = {
+  // TODO: define output
+}
+
+export const ${name} = pikkuSessionlessFunc<${inputName}, ${outputName}>({
+  func: async ({ logger }, data) => {
+    // TODO: implement
+    return {} as ${outputName}
+  },
+})
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created function at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-middleware.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewMiddleware: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-middleware.js

@@ -0,0 +1,48 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+export const pikkuNewMiddleware = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'simple' }) => {
+        const filePath = scaffoldFilePath(config, 'middleware', name, '.ts', config.scaffold?.middlewareDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        let content;
+        switch (type) {
+            case 'factory':
+                content = `import { pikkuMiddlewareFactory } from '#pikku'
+
+export const ${name} = pikkuMiddlewareFactory(
+  (param: string) =>
+    async ({ logger }, _data, next) => {
+      logger.info(\`[\${param}] before\`)
+      const result = await next()
+      logger.info(\`[\${param}] after\`)
+      return result
+    }
+)
+`;
+                break;
+            case 'simple':
+            default:
+                content = `import { pikkuMiddleware } from '#pikku'
+
+export const ${name} = pikkuMiddleware(
+  async ({ logger }, _data, next) => {
+    // TODO: implement
+    const result = await next()
+    return result
+  }
+)
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created middleware at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-permission.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewPermission: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-permission.js

@@ -0,0 +1,45 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+export const pikkuNewPermission = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'simple' }) => {
+        const filePath = scaffoldFilePath(config, 'permissions', name, '.ts', config.scaffold?.permissionDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        let content;
+        switch (type) {
+            case 'factory':
+                content = `import { pikkuPermissionFactory } from '#pikku'
+
+export const ${name} = pikkuPermissionFactory(
+  (param: string) =>
+    async ({ logger }, _data, { session }) => {
+      // TODO: implement permission check
+      return true
+    }
+)
+`;
+                break;
+            case 'simple':
+            default:
+                content = `import { pikkuPermission } from '#pikku'
+
+export const ${name} = pikkuPermission(
+  async ({ logger }, _data, { session }) => {
+    // TODO: implement permission check
+    return true
+  }
+)
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created permission at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-wiring.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewWiring: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-wiring.js

@@ -0,0 +1,102 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+function getWiringTemplate(type, name) {
+    switch (type) {
+        case 'http':
+            return `import { wireHTTP } from '#pikku'
+// import { myFunc } from '../functions/${name}.functions.js'
+
+wireHTTP({
+  method: 'get',
+  route: '/api/${name}',
+  func: myFunc,
+  auth: false,
+})
+`;
+        case 'channel':
+            return `import { wireChannel } from '#pikku'
+// import { onConnect, onMessage, onDisconnect } from '../functions/${name}.functions.js'
+
+wireChannel({
+  name: '${name}',
+  route: '/',
+  onConnect,
+  onDisconnect,
+  onMessage,
+  auth: true,
+})
+`;
+        case 'scheduler':
+            return `import { wireScheduler } from '#pikku'
+// import { myTask } from '../functions/${name}.functions.js'
+
+wireScheduler({
+  name: '${name}',
+  schedule: '0 * * * *',
+  func: myTask,
+})
+`;
+        case 'queue':
+            return `import { wireQueueWorker } from '#pikku'
+// import { processItem } from '../functions/${name}.functions.js'
+
+wireQueueWorker({
+  name: '${name}',
+  func: processItem,
+})
+`;
+        case 'mcp':
+            return `import { wireMCPResource } from '#pikku'
+// import { myResource } from '../functions/${name}.functions.js'
+
+wireMCPResource({
+  uri: '${name}',
+  title: '${name}',
+  description: 'TODO: describe this resource',
+  func: myResource,
+})
+`;
+        case 'cli':
+            return `import { wireCLI, pikkuCLICommand } from '#pikku'
+// import { myCommand } from '../functions/${name}.functions.js'
+
+wireCLI({
+  program: '${name}',
+  commands: {
+    example: pikkuCLICommand({
+      func: myCommand,
+      description: 'TODO: describe this command',
+    }),
+  },
+})
+`;
+        case 'trigger':
+            return `import { wireTrigger } from '#pikku'
+// import { handleEvent } from '../functions/${name}.functions.js'
+
+wireTrigger({
+  name: '${name}',
+  func: handleEvent,
+})
+`;
+        default:
+            return `// ${type} wiring for ${name}\n`;
+    }
+}
+export const pikkuNewWiring = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'http' }) => {
+        const filePath = scaffoldFilePath(config, 'wirings', name, '.wiring.ts', config.scaffold?.wiringDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        const content = getWiringTemplate(type, name);
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created wiring at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/pikku-command-bootstrap.d.ts

@@ -0,0 +1,4 @@
+export type BootstrapInput = {
+    allImports: string[];
+};
+export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<BootstrapInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -0,0 +1,38 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../utils/file-import-path.js';
+import { writeFileInDir } from '../../utils/file-writer.js';
+export const pikkuBootstrap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }, { allImports }) => {
+        const stateBeforeBootstrap = await getInspectorState();
+        const addonBootstraps = [];
+        for (const [, decl] of stateBeforeBootstrap.rpc?.wireAddonDeclarations ??
+            []) {
+            addonBootstraps.push(`${decl.package}/.pikku/pikku-bootstrap.gen.js`);
+            logger.debug(`• Addon bootstrap: ${decl.package}`);
+        }
+        const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const addonImports = addonBootstraps.map((packagePath) => `import '${packagePath}'`);
+        const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
+        const metaDirRegistration = `import { pikkuState as __pikkuState } from '@pikku/core/internal'
+try {
+  const { fileURLToPath: __fileURLToPath } = await import('url')
+  const { dirname: __dirname } = await import('path')
+  __pikkuState(${packageNameArg}, 'package', 'metaDir', __dirname(__fileURLToPath(import.meta.url)))
+} catch {}
+`;
+        const allBootstrapImports = metaDirRegistration +
+            [...localImports, ...wireAddonFileImports, ...addonImports]
+                .sort((a, b) => {
+                const aMeta = a.includes('meta');
+                const bMeta = b.includes('meta');
+                if (aMeta && !bMeta)
+                    return -1;
+                if (!aMeta && bMeta)
+                    return 1;
+                return 0;
+            })
+                .join('\n');
+        await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports);
+    },
+});

package/dist/src/functions/commands/pikku-command-summary.d.ts

@@ -0,0 +1 @@
+export declare const pikkuSummary: 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/commands/pikku-command-summary.js

@@ -0,0 +1,55 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { CommandSummary } from '../../utils/command-summary.js';
+export const pikkuSummary = pikkuSessionlessFunc({
+    func: async ({ logger, getInspectorState }) => {
+        const summary = new CommandSummary('all');
+        const state = await getInspectorState();
+        if (state.http?.meta) {
+            const httpRouteCount = Object.values(state.http.meta).reduce((sum, routes) => sum + Object.keys(routes).length, 0);
+            if (httpRouteCount > 0)
+                summary.set('httpRoutes', httpRouteCount);
+        }
+        if (state.channels?.meta) {
+            summary.set('channels', Object.keys(state.channels.meta).length);
+        }
+        if (state.scheduledTasks?.meta) {
+            summary.set('scheduledTasks', Object.keys(state.scheduledTasks.meta).length);
+        }
+        if (state.triggers?.meta) {
+            const triggerCount = Object.keys(state.triggers.meta).length;
+            if (triggerCount > 0)
+                summary.set('triggers', triggerCount);
+        }
+        if (state.queueWorkers?.meta) {
+            summary.set('queueWorkers', Object.keys(state.queueWorkers.meta).length);
+        }
+        if (state.mcpEndpoints) {
+            const mcpTotal = Object.keys(state.mcpEndpoints.toolsMeta || {}).length +
+                Object.keys(state.mcpEndpoints.resourcesMeta || {}).length +
+                Object.keys(state.mcpEndpoints.promptsMeta || {}).length;
+            if (mcpTotal > 0)
+                summary.set('mcpEndpoints', mcpTotal);
+        }
+        if (state.cli?.meta) {
+            const totalCommands = Object.values(state.cli.meta).reduce((sum, program) => sum + (program.commands?.length || 0), 0);
+            if (totalCommands > 0)
+                summary.set('cliCommands', totalCommands);
+        }
+        if (state.workflows?.meta) {
+            summary.set('workflows', Object.keys(state.workflows.meta).length);
+        }
+        if (state.nodes?.meta) {
+            const nodesCount = Object.keys(state.nodes.meta).length;
+            if (nodesCount > 0)
+                summary.set('nodes', nodesCount);
+        }
+        if (state.workflows?.graphMeta) {
+            const workflowGraphsCount = Object.keys(state.workflows.graphMeta).length;
+            if (workflowGraphsCount > 0)
+                summary.set('workflowGraphs', workflowGraphsCount);
+        }
+        if (!logger.isSilent()) {
+            console.log(summary.format());
+        }
+    },
+});

package/dist/src/functions/commands/versions-check.d.ts

@@ -0,0 +1 @@
+export declare const pikkuVersionsCheck: 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/commands/versions-check.js

@@ -0,0 +1,99 @@
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+function hashArrow(prev, curr) {
+    const p = (prev ?? 'unknown').slice(0, 8);
+    const c = (curr ?? 'unknown').slice(0, 8);
+    if (p === c) {
+        return `${p} (unchanged)`;
+    }
+    return `${p} → ${c}`;
+}
+export const pikkuVersionsCheck = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        if (!visitState.manifest.initial) {
+            const manifestPath = join(config.outDir, 'versions.json');
+            throw new Error(`[${ErrorCode.MANIFEST_MISSING}] Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
+        }
+        if (visitState.manifest.errors.length > 0) {
+            for (const error of visitState.manifest.errors) {
+                if (error.code === ErrorCode.CONTRACT_CHANGED_REQUIRES_BUMP &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey} — contract changed without version bump`);
+                    if (error.previousInputHash !== undefined ||
+                        error.currentInputHash !== undefined) {
+                        logger.info(`  Input schema hash:  ${hashArrow(error.previousInputHash, error.currentInputHash)}`);
+                        logger.info(`  Output schema hash: ${hashArrow(error.previousOutputHash, error.currentOutputHash)}`);
+                    }
+                    logger.info(``);
+                    if (error.nextVersion !== undefined) {
+                        logger.info(`  Set \`version: ${error.nextVersion}\` on the function, then run:`);
+                    }
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else if (error.code === ErrorCode.FUNCTION_VERSION_MODIFIED &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — published contract was modified`);
+                    if (error.previousInputHash !== undefined ||
+                        error.currentInputHash !== undefined) {
+                        logger.info(`  Recorded hash: ${(error.previousInputHash ?? 'unknown').slice(0, 8)}`);
+                        logger.info(`  Current hash:  ${(error.currentInputHash ?? 'unknown').slice(0, 8)}`);
+                    }
+                    logger.info(``);
+                    logger.info(`  Published versions are immutable. Either revert`);
+                    logger.info(`  the schema change or create version ${(error.version ?? 1) + 1} instead.`);
+                }
+                else if (error.code === ErrorCode.VERSION_REGRESSION_OR_CONFLICT &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — version missing from manifest`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  Latest recorded version: ${error.latestVersion}`);
+                    }
+                    logger.info(`  Version ${error.version} exists in code but not in versions.json`);
+                    logger.info(``);
+                    logger.info(`  This usually means a merge conflict in versions.json.`);
+                    logger.info(`  Resolve the conflict, then run:`);
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else if (error.code === ErrorCode.VERSION_GAP_NOT_ALLOWED &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — version gap detected`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  Latest version: ${error.latestVersion}`);
+                    }
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Expected next:  ${error.expectedNextVersion}`);
+                    }
+                    if (error.version !== undefined) {
+                        logger.info(`  Found:          ${error.version}`);
+                    }
+                    logger.info(``);
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Versions must be sequential. Set \`version: ${error.expectedNextVersion}\``);
+                        logger.info(`  on the function.`);
+                    }
+                }
+                else if (error.code === ErrorCode.MANIFEST_INTEGRITY_ERROR &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey} — versions.json integrity error`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  "latest" field: ${error.latestVersion}`);
+                    }
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Highest version key: ${error.expectedNextVersion}`);
+                    }
+                    logger.info(``);
+                    logger.info(`  The manifest is corrupted. Run:`);
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else {
+                    logger.info(`[${error.code}] ${error.message}`);
+                }
+                logger.info(``);
+            }
+            throw new Error('Version check failed.');
+        }
+        logger.info('Version manifest check passed.');
+    },
+});

package/dist/src/functions/commands/versions-init.d.ts

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

package/dist/src/functions/commands/versions-init.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
+export const pikkuVersionsInit = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { force }) => {
+        const manifestPath = join(config.outDir, 'versions.json');
+        if (existsSync(manifestPath) && !force) {
+            logger.error(`Version manifest already exists at ${manifestPath}. Use --force to overwrite.`);
+            process.exit(1);
+        }
+        await saveManifest(manifestPath, createEmptyManifest());
+        logger.info(`Version manifest created at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/versions-update.d.ts

@@ -0,0 +1 @@
+export declare const pikkuVersionsUpdate: 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/commands/versions-update.js

@@ -0,0 +1,20 @@
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+import { saveManifest } from '../../utils/contract-versions.js';
+export const pikkuVersionsUpdate = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const manifestPath = join(config.outDir, 'versions.json');
+        const visitState = await getInspectorState();
+        if (!visitState.manifest.initial) {
+            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
+        }
+        const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
+        if (immutabilityErrors.length > 0) {
+            const messages = immutabilityErrors.map((e) => `[${e.code}] ${e.message}`);
+            throw new Error(messages.join('\n'));
+        }
+        await saveManifest(manifestPath, visitState.manifest.current);
+        logger.debug(`Version manifest updated at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/watch.d.ts

@@ -1 +1 @@
-export declare const watch: any;
+export declare const watch: 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/commands/watch.js

@@ -1,9 +1,8 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+import { pikkuVoidFunc } from '#pikku';
 import chokidar from 'chokidar';
-import { all } from './all.js';
 export const watch = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const services = { logger, config, getInspectorState };
+    remote: true,
+    func: async ({ logger, config }, _data, { rpc }) => {
         const configWatcher = chokidar.watch(config.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
@@ -20,7 +19,7 @@ export const watch = pikkuVoidFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await all.func(services, null, {});
+                        await rpc.invoke('all', null);
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -0,0 +1 @@
+export declare const pikkuFetch: 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 → runtimes}/fetch/index.js

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFetchWrapper } from '../../wirings/http/serialize-fetch-wrapper.js';
 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';
@@ -8,7 +8,7 @@ export const pikkuFetch = pikkuSessionlessFunc({
         const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
         // If fetchFile is not set, clean up any existing file and return
         if (!fetchFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
                 type: 'skip',
             });

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -1 +1 @@
-export declare const pikkuNext: any;
+export declare const pikkuNext: 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>;