@pikku/cli 0.12.20 → 0.12.22

package/dist/src/functions/commands/dev.js

@@ -1,72 +1,21 @@
-import { createServer } from 'http';
+import { existsSync } from 'fs';
 import { join, resolve } from 'path';
-import { Readable } from 'stream';
 import { pikkuSessionlessFunc } from '#pikku';
 import chokidar from 'chokidar';
 import { pikkuDevReloader } from '@pikku/core/dev';
 import { ConsoleLogger, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
 import { pikkuState } from '@pikku/core/internal';
-import { fetchData, PikkuFetchHTTPResponse, logRoutes, } from '@pikku/core/http';
-import { compileAllSchemas } from '@pikku/core/schema';
+import { LocalMetaService } from '@pikku/core/services/local-meta';
+import { LocalEventHubService } from '@pikku/core/channel/local';
+import { LocalContent, } from '@pikku/core/services/local-content';
 import { pikkuWebsocketHandler } from '@pikku/ws';
+import { PikkuNodeHTTPServer } from '@pikku/node-http-server';
 import { WebSocketServer } from 'ws';
 import { InMemorySchedulerService } from '@pikku/schedule';
-function incomingMessageToRequest(req) {
-    const url = new URL(req.url || '/', 'http://localhost');
-    const method = req.method ? req.method.toUpperCase() : 'GET';
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(req.headers)) {
-        if (value) {
-            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
-        }
-    }
-    let body = null;
-    if (method !== 'GET' && method !== 'HEAD') {
-        body = Readable.toWeb(req);
-    }
-    return new Request(url.toString(), {
-        method,
-        headers,
-        body,
-        // @ts-ignore - duplex is needed for streaming body in Node.js
-        duplex: 'half',
-    });
-}
-async function writeResponse(nodeRes, webResponse) {
-    const headers = {};
-    webResponse.headers.forEach((value, name) => {
-        const lower = name.toLowerCase();
-        if (lower === 'set-cookie') {
-            const existing = headers[lower];
-            if (Array.isArray(existing)) {
-                existing.push(value);
-            }
-            else {
-                headers[lower] = [value];
-            }
-        }
-        else {
-            headers[lower] = value;
-        }
-    });
-    nodeRes.writeHead(webResponse.status, headers);
-    if (webResponse.body) {
-        const reader = webResponse.body.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                nodeRes.write(value);
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    nodeRes.end();
-}
+import { resolveLocalDb, createKysely } from '../db/local-db.js';
+import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config, getInspectorState }, { port, watch, hmr }, { rpc }) => {
@@ -74,50 +23,156 @@ export const dev = pikkuSessionlessFunc({
         const hostname = 'localhost';
         const enableWatch = watch !== false;
         const enableHmr = hmr !== false;
-        await rpc.invoke('all');
+        const commandSingletonServices = pikkuState(null, 'package', 'singletonServices');
+        const commandFunctionMeta = {
+            ...pikkuState(null, 'function', 'meta'),
+        };
+        const commandFunctions = new Map(pikkuState(null, 'function', 'functions'));
+        const commandRPCMeta = {
+            ...pikkuState(null, 'rpc', 'meta'),
+        };
+        const commandWorkflowsMeta = {
+            ...pikkuState(null, 'workflows', 'meta'),
+        };
+        const commandWorkflowRegistrations = new Map(pikkuState(null, 'workflows', 'registrations'));
+        const workflowService = new InMemoryWorkflowService();
+        const pikkuDir = resolve(config.rootDir, config.outDir);
+        const bootstrapExists = existsSync(resolve(pikkuDir, 'pikku-bootstrap.gen.ts')) ||
+            existsSync(resolve(pikkuDir, 'pikku-bootstrap.gen.js'));
+        const runAll = async () => {
+            await workflowService.runToCompletion('allWorkflow', {}, rpc);
+        };
+        const runAllWithCommandState = async () => {
+            const previousSingletonServices = pikkuState(null, 'package', 'singletonServices');
+            const previousFunctions = pikkuState(null, 'function', 'functions');
+            const previousFunctionMeta = pikkuState(null, 'function', 'meta');
+            const previousRPCMeta = pikkuState(null, 'rpc', 'meta');
+            const previousWorkflowsMeta = pikkuState(null, 'workflows', 'meta');
+            const previousWorkflowRegistrations = pikkuState(null, 'workflows', 'registrations');
+            pikkuState(null, 'package', 'singletonServices', commandSingletonServices);
+            pikkuState(null, 'function', 'functions', new Map([...previousFunctions.entries(), ...commandFunctions.entries()]));
+            pikkuState(null, 'function', 'meta', {
+                ...previousFunctionMeta,
+                ...commandFunctionMeta,
+            });
+            pikkuState(null, 'rpc', 'meta', {
+                ...previousRPCMeta,
+                ...commandRPCMeta,
+            });
+            pikkuState(null, 'workflows', 'meta', {
+                ...previousWorkflowsMeta,
+                ...commandWorkflowsMeta,
+            });
+            pikkuState(null, 'workflows', 'registrations', new Map([
+                ...previousWorkflowRegistrations.entries(),
+                ...commandWorkflowRegistrations.entries(),
+            ]));
+            try {
+                await runAll();
+            }
+            finally {
+                pikkuState(null, 'package', 'singletonServices', previousSingletonServices);
+                pikkuState(null, 'function', 'functions', previousFunctions);
+                pikkuState(null, 'function', 'meta', previousFunctionMeta);
+                pikkuState(null, 'rpc', 'meta', previousRPCMeta);
+                pikkuState(null, 'workflows', 'meta', previousWorkflowsMeta);
+                pikkuState(null, 'workflows', 'registrations', previousWorkflowRegistrations);
+            }
+        };
+        if (bootstrapExists) {
+            await loadUserBootstrap(pikkuDir);
+        }
+        await runAllWithCommandState();
         const inspectorState = await getInspectorState(true);
         const { pikkuConfigFactory, singletonServicesFactory } = inspectorState.filesAndMethods;
         if (!pikkuConfigFactory || !singletonServicesFactory) {
             logger.error('createConfig and createSingletonServices must be defined in your project');
             return;
         }
-        const pikkuDir = resolve(config.rootDir, config.outDir);
-        const bootstrapPath = join(pikkuDir, 'pikku-bootstrap.gen.js');
-        await import(bootstrapPath);
-        const configModule = await import(pikkuConfigFactory.file);
-        const servicesModule = await import(singletonServicesFactory.file);
+        if (!bootstrapExists) {
+            await loadUserBootstrap(pikkuDir);
+        }
+        workflowService.rewireQueueWorkers();
+        const configModule = await loadUserModule(pikkuConfigFactory.file);
+        const servicesModule = await loadUserModule(singletonServicesFactory.file);
         const userCreateConfig = configModule[pikkuConfigFactory.variable];
         const userCreateSingletonServices = servicesModule[singletonServicesFactory.variable];
         const userConfig = await userCreateConfig();
+        const resolvedLocalDb = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        const kysely = resolvedLocalDb
+            ? await createKysely(resolvedLocalDb)
+            : undefined;
+        const resolvedRuntimeDir = config.runtimeDir ?? join(config.rootDir, '.pikku-runtime');
+        const localContentConfig = userConfig.dev
+            ?.content
+            ? {
+                localFileUploadPath: join(resolvedRuntimeDir, 'content'),
+                uploadUrlPrefix: '/upload',
+                assetUrlPrefix: '/assets',
+                server: `http://${hostname}:${resolvedPort}`,
+                ...(userConfig.dev.content !== true ? userConfig.dev.content : {}),
+            }
+            : undefined;
+        const localContent = localContentConfig
+            ? new LocalContent(localContentConfig, logger)
+            : undefined;
         const schedulerService = new InMemorySchedulerService();
+        const aiStorage = kysely
+            ? new KyselyAIStorageService(kysely)
+            : undefined;
+        const aiRunState = kysely
+            ? new KyselyAIRunStateService(kysely)
+            : new InMemoryAIRunStateService();
+        const agentRunService = kysely
+            ? new KyselyAgentRunService(kysely)
+            : undefined;
+        if (aiStorage)
+            await aiStorage.init();
+        if ('init' in aiRunState && typeof aiRunState.init === 'function') {
+            await aiRunState.init();
+        }
+        // InMemoryWorkflowService implements both the workflowService and
+        // workflowRunService surfaces (listRuns/getRun live on it). Expose the
+        // single instance under both names so addons like @pikku/addon-console
+        // can read runs in dev without projects having to wire their own backing
+        // store.
         const inMemoryServices = {
             logger: new ConsoleLogger(),
+            metaService: new LocalMetaService(pikkuDir),
             schedulerService,
             queueService: new InMemoryQueueService(),
-            workflowService: new InMemoryWorkflowService(),
+            workflowService,
+            workflowRunService: workflowService,
             triggerService: new InMemoryTriggerService(),
-            aiRunStateService: new InMemoryAIRunStateService(),
+            aiStorage,
+            aiRunState,
+            agentRunService,
+            eventHub: new LocalEventHubService(),
+            ...(kysely ? { kysely } : {}),
+            ...(localContent ? { content: localContent } : {}),
         };
-        const singletonServices = await userCreateSingletonServices(userConfig, inMemoryServices);
-        pikkuState(null, 'package', 'singletonServices', singletonServices);
-        compileAllSchemas(logger);
-        logRoutes(logger);
-        const server = createServer(async (req, res) => {
-            const request = incomingMessageToRequest(req);
-            const pikkuResponse = new PikkuFetchHTTPResponse();
-            await fetchData(request, pikkuResponse, { respondWith404: true });
-            const response = pikkuResponse.toResponse();
-            await writeResponse(res, response);
+        const singletonServices = await userCreateSingletonServices(userConfig, {
+            ...inMemoryServices,
+            getInspectorState,
+        });
+        pikkuState(null, 'package', 'singletonServices', {
+            ...singletonServices,
+            getInspectorState,
         });
         const wss = new WebSocketServer({ noServer: true });
-        pikkuWebsocketHandler({ server, wss, logger });
-        await schedulerService.start();
-        await new Promise((resolve) => {
-            server.listen(resolvedPort, hostname, () => {
-                logger.info(`Dev server running at http://${hostname}:${resolvedPort}`);
-                resolve();
-            });
+        const pikkuServer = new PikkuNodeHTTPServer({
+            ...userConfig,
+            hostname,
+            port: resolvedPort,
+            content: localContentConfig,
+        }, logger, {
+            configureServer: (httpServer) => {
+                pikkuWebsocketHandler({ server: httpServer, wss, logger });
+            },
         });
+        await pikkuServer.init();
+        await schedulerService.start();
+        await pikkuServer.start();
         let configWatcher;
         let watcher;
         process.once('SIGINT', async () => {
@@ -127,7 +182,7 @@ export const dev = pikkuSessionlessFunc({
                 await configWatcher?.close();
                 await watcher?.close();
                 await new Promise((resolve, reject) => wss.close((err) => (err ? reject(err) : resolve())));
-                await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+                await pikkuServer.stop();
             }
             finally {
                 process.exit(0);
@@ -156,7 +211,8 @@ export const dev = pikkuSessionlessFunc({
                     const handle = async () => {
                         try {
                             const start = Date.now();
-                            await rpc.invoke('all');
+                            await runAllWithCommandState();
+                            workflowService.rewireQueueWorkers();
                             logger.info({
                                 message: `✓ Generated in ${Date.now() - start}ms`,
                                 type: 'timing',

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

@@ -1,4 +1,5 @@
-export declare const enableRpc: 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>;
-export declare const enableConsole: 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>;
-export declare const enableAgent: 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>;
-export declare const enableWorkflow: 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>;
+export declare const enableRpc: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const enableConsole: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const enableAgent: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const enableWorkflow: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const enableEvents: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/enable.js

@@ -6,6 +6,7 @@ const FEATURE_DEFAULTS = {
     agent: 'auth',
     console: 'no-auth',
     workflow: 'auth',
+    events: 'auth',
 };
 async function enableFeature(feature, logger, config, data) {
     const noAuth = data?.noAuth ?? false;
@@ -37,3 +38,6 @@ export const enableAgent = pikkuVoidFunc({
 export const enableWorkflow = pikkuVoidFunc({
     func: async ({ logger, config }, data) => enableFeature('workflow', logger, config, data),
 });
+export const enableEvents = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('events', logger, config, data),
+});

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

@@ -2,8 +2,8 @@ type InfoInput = {
     limit?: string;
     verbose?: boolean;
 };
-export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
-export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
-export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
-export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/load-user-project.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Load the generated `pikku-bootstrap.gen.{ts,js}` from the user's project,
+ * which in turn pulls in all wiring/meta files so they register into
+ * `pikkuState`.
+ */
+export declare function loadUserBootstrap(pikkuDir: string): Promise<void>;
+/**
+ * Import a user-source TypeScript file (e.g. their config or services
+ * factory) so it can be loaded from inside @pikku/cli's compiled JS.
+ */
+export declare function loadUserModule(filePath: string): Promise<Record<string, any>>;

package/dist/src/functions/commands/load-user-project.js

@@ -0,0 +1,40 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { register } from 'tsx/esm/api';
+let tsxRegistered = false;
+/**
+ * Globally register tsx so subsequent `import()` calls go through Node's
+ * normal resolver — yielding ONE module graph (and one shared pikkuState),
+ * with tsx only stepping in to compile `.ts` and rewrite `.js → .ts`.
+ *
+ * `tsImport` from tsx/esm/api creates a fresh, isolated loader per call, so
+ * modules imported through it have a different identity than modules already
+ * loaded in the CLI process — that breaks anything that relies on shared
+ * module state (e.g. `pikkuState` registrations from wireHTTPRoutes).
+ */
+function ensureTsxRegistered() {
+    if (tsxRegistered)
+        return;
+    register();
+    tsxRegistered = true;
+}
+/**
+ * Load the generated `pikku-bootstrap.gen.{ts,js}` from the user's project,
+ * which in turn pulls in all wiring/meta files so they register into
+ * `pikkuState`.
+ */
+export async function loadUserBootstrap(pikkuDir) {
+    ensureTsxRegistered();
+    const bootstrapTs = join(pikkuDir, 'pikku-bootstrap.gen.ts');
+    const bootstrapJs = join(pikkuDir, 'pikku-bootstrap.gen.js');
+    const bootstrapPath = existsSync(bootstrapTs) ? bootstrapTs : bootstrapJs;
+    await import(bootstrapPath);
+}
+/**
+ * Import a user-source TypeScript file (e.g. their config or services
+ * factory) so it can be loaded from inside @pikku/cli's compiled JS.
+ */
+export async function loadUserModule(filePath) {
+    ensureTsxRegistered();
+    return import(filePath);
+}

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

@@ -0,0 +1,82 @@
+export declare const pikkuMetaFunctionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaFunctionsGet: import("#pikku").PikkuFunctionConfig<{
+    functionId: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    functionId: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    functionId: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaSchemasList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaSchemasGet: import("#pikku").PikkuFunctionConfig<{
+    schemaName: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    schemaName: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    schemaName: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWorkflowsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWorkflowsGet: import("#pikku").PikkuFunctionConfig<{
+    workflowId: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    workflowId: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    workflowId: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaMiddlewareList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaMiddlewareGet: import("#pikku").PikkuFunctionConfig<{
+    middlewareId: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    middlewareId: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    middlewareId: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaPermissionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaPermissionsGet: import("#pikku").PikkuFunctionConfig<{
+    permissionId: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    permissionId: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    permissionId: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresType: import("#pikku").PikkuFunctionConfig<{
+    type: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    type: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    type: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresHttp: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresScheduler: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresQueue: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresChannel: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+/**
+ * Bulk context endpoint.
+ *
+ * Single inspection → returns everything a planner needs for first-pass
+ * planning: functions, all wires, middleware, permissions, workflows, plus
+ * project capabilities (which wire types are in use) and layout (where new
+ * files should land). Designed to replace the 6+ list calls in the planner
+ * spec — one process spawn, one inspect, ~all the metadata.
+ *
+ * Targeted `pikku meta * get` calls are still the right tool when the planner
+ * wants schema details (input/output JSON schemas) for a specific entry.
+ */
+export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+/**
+ * Frontend-targeted metadata.
+ *
+ * Returns only what a UI agent needs to write client code:
+ *   - RPCs: every exposed function with input/output type names,
+ *     description, readonly flag, tags.
+ *   - Workflows: name, description, mode (inline|distributed), input/output
+ *     types resolved through the workflow's underlying function.
+ *   - Channels: name, route, description, plus the input/output types of
+ *     the connect / disconnect / message handlers and any routed messages.
+ *
+ * Everything else (middleware, permissions, layout, scaffold dirs,
+ * non-exposed functions, http wires) is a backend concern and stays in
+ * `pikku meta context`.
+ */
+export declare const pikkuMetaClients: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;