@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,27 +1,18 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
-import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
-import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
-import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
-import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
-import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
-import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
-import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js';
-import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
-import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
+import { pikkuVoidFunc } from '#pikku';
 export const bootstrap = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const wire = {};
-        const services = { logger, config, getInspectorState };
+    remote: true,
+    func: async ({ logger, getInspectorState }, _data, { rpc }) => {
         await getInspectorState(false, false, true);
-        await pikkuFunctionTypes.func(services, null, wire);
-        await pikkuFunctionTypesSplit.func(services, null, wire);
-        await pikkuHTTPTypes.func(services, null, wire);
-        await pikkuChannelTypes.func(services, null, wire);
-        await pikkuSchedulerTypes.func(services, null, wire);
-        await pikkuQueueTypes.func(services, null, wire);
-        await pikkuWorkflow.func(services, null, wire);
-        await pikkuMCPTypes.func(services, null, wire);
-        await pikkuCLITypes.func(services, null, wire);
+        await rpc.invoke('pikkuFunctionTypes', null);
+        await rpc.invoke('pikkuFunctionTypesSplit', null);
+        await rpc.invoke('pikkuHTTPTypes', null);
+        await rpc.invoke('pikkuChannelTypes', null);
+        await rpc.invoke('pikkuSchedulerTypes', null);
+        await rpc.invoke('pikkuQueueTypes', null);
+        await rpc.invoke('pikkuWorkflow', null);
+        await rpc.invoke('pikkuMCPTypes', null);
+        await rpc.invoke('pikkuAIAgentTypes', null);
+        await rpc.invoke('pikkuCLITypes', null);
         if (logger.hasCriticalErrors()) {
             process.exit(1);
         }

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

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

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

@@ -0,0 +1,106 @@
+import { createServer } from 'http';
+import { readFile, stat } from 'fs/promises';
+import { join, extname } from 'path';
+import { fileURLToPath } from 'url';
+import { pikkuSessionlessFunc } from '#pikku';
+import chokidar from 'chokidar';
+import open from 'open';
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.webmanifest': 'application/manifest+json',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.map': 'application/json',
+};
+export const consoleCommand = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config }, { port }, { rpc }) => {
+        const consoleDir = join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'console-app');
+        const resolvedPort = parseInt(port || '51442', 10);
+        try {
+            await stat(consoleDir);
+        }
+        catch {
+            logger.error('Console app not found. Please rebuild @pikku/cli with the console app bundled.');
+            return;
+        }
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url || '/', `http://localhost:${resolvedPort}`);
+            let filePath = join(consoleDir, url.pathname);
+            try {
+                const fileStat = await stat(filePath);
+                if (fileStat.isDirectory()) {
+                    filePath = join(filePath, 'index.html');
+                }
+            }
+            catch {
+                filePath = join(consoleDir, 'index.html');
+            }
+            try {
+                const content = await readFile(filePath);
+                const ext = extname(filePath);
+                const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found');
+            }
+        });
+        server.listen(resolvedPort, () => {
+            logger.info(`Pikku Console running at http://localhost:${resolvedPort}`);
+            open(`http://localhost:${resolvedPort}`);
+        });
+        const configWatcher = chokidar.watch(config.srcDirectories, {
+            ignoreInitial: true,
+            ignored: /.*\.gen\.tsx?/,
+        });
+        let watcher = new chokidar.FSWatcher({});
+        const generatorWatcher = () => {
+            watcher.close();
+            logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(config.srcDirectories, {
+                ignoreInitial: true,
+                ignored: /.*\.gen\.ts/,
+            });
+            watcher.on('ready', async () => {
+                const handle = async () => {
+                    try {
+                        const start = Date.now();
+                        await rpc.invoke('all', null);
+                        logger.info({
+                            message: `✓ Generated in ${Date.now() - start}ms`,
+                            type: 'timing',
+                        });
+                    }
+                    catch (err) {
+                        console.error(err);
+                        logger.error('Error running watch');
+                    }
+                };
+                await handle();
+                let timeout;
+                const deduped = (_file) => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    timeout = setTimeout(handle, 10);
+                };
+                watcher.on('change', deduped);
+                watcher.on('add', deduped);
+                watcher.on('unlink', deduped);
+            });
+        };
+        configWatcher.on('ready', generatorWatcher);
+        configWatcher.on('change', generatorWatcher);
+        await new Promise(() => { });
+    },
+});

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

@@ -0,0 +1,9 @@
+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 {};

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

@@ -0,0 +1,283 @@
+import path from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+const printTable = (headers, rows, limit) => {
+    const all = [headers, ...rows.slice(0, limit)];
+    const widths = headers.map((_, col) => Math.max(...all.map((row) => (row[col] ?? '').length)));
+    const line = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join('  ');
+    console.log(line(headers));
+    console.log(widths.map((w) => '-'.repeat(w)).join('  '));
+    for (const row of rows.slice(0, limit)) {
+        console.log(line(row));
+    }
+    if (rows.length > limit) {
+        console.log(`... and ${rows.length - limit} more (use --limit to show more)`);
+    }
+};
+const getFunctionTypes = (funcId, state) => {
+    const types = [];
+    if (state.http?.meta) {
+        for (const routes of Object.values(state.http.meta)) {
+            for (const meta of Object.values(routes)) {
+                if (meta.pikkuFuncId === funcId)
+                    types.push('http');
+            }
+        }
+    }
+    if (state.channels?.meta) {
+        for (const channel of Object.values(state.channels.meta)) {
+            const messages = [channel.connect, channel.disconnect, channel.message];
+            for (const msg of messages) {
+                if (msg && msg.pikkuFuncId === funcId)
+                    types.push('channel');
+            }
+        }
+    }
+    if (state.scheduledTasks?.meta) {
+        if (funcId in state.scheduledTasks.meta)
+            types.push('scheduler');
+    }
+    if (state.queueWorkers?.meta) {
+        if (funcId in state.queueWorkers.meta)
+            types.push('queue');
+    }
+    if (state.workflows?.meta) {
+        if (funcId in state.workflows.meta)
+            types.push('workflow');
+    }
+    if (state.mcpEndpoints?.toolsMeta) {
+        if (funcId in state.mcpEndpoints.toolsMeta)
+            types.push('mcp');
+    }
+    if (state.cli?.meta) {
+        for (const program of Object.values(state.cli.meta)) {
+            if (program.commands) {
+                for (const cmd of program.commands) {
+                    if (cmd.pikkuFuncId === funcId)
+                        types.push('cli');
+                }
+            }
+        }
+    }
+    if (state.triggers?.meta) {
+        if (funcId in state.triggers.meta)
+            types.push('trigger');
+    }
+    return [...new Set(types)];
+};
+const getFilePath = (funcId, state) => {
+    const entry = state.functions.files.get(funcId);
+    if (entry) {
+        return path.relative(state.rootDir, entry.path);
+    }
+    return '';
+};
+const formatMetadata = (meta) => {
+    if (!meta || meta.length === 0)
+        return '';
+    return meta
+        .map((m) => {
+        if ('name' in m)
+            return m.name;
+        if ('type' in m)
+            return m.type;
+        return '?';
+    })
+        .join(', ');
+};
+export const pikkuInfoFunctions = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const meta = state.functions.meta;
+        const entries = Object.entries(meta);
+        if (entries.length === 0) {
+            console.log('No functions found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['pikkuFuncId', 'name', 'tags'];
+            const rows = entries.map(([id, m]) => [
+                id,
+                m.name ?? '',
+                (m.tags ?? []).join(', '),
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'pikkuFuncId',
+                'name',
+                'tags',
+                'type',
+                'middleware',
+                'permissions',
+                'file',
+            ];
+            const rows = entries.map(([id, m]) => [
+                id,
+                m.name ?? '',
+                (m.tags ?? []).join(', '),
+                getFunctionTypes(id, state).join(', '),
+                formatMetadata(m.middleware),
+                formatMetadata(m.permissions),
+                getFilePath(id, state),
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoTags = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const meta = state.functions.meta;
+        const tagMap = new Map();
+        for (const [id, m] of Object.entries(meta)) {
+            for (const tag of m.tags ?? []) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).funcIds.push(m.name ?? id);
+            }
+        }
+        const tagMiddleware = state.middleware?.tagMiddleware;
+        if (tagMiddleware) {
+            for (const [tag, group] of tagMiddleware) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).middlewareNames.push(...(group.instanceIds ?? []));
+            }
+        }
+        const tagPermissions = state.permissions?.tagPermissions;
+        if (tagPermissions) {
+            for (const [tag, group] of tagPermissions) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).permissionNames.push(...(group.instanceIds ?? []));
+            }
+        }
+        const tags = [...tagMap.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+        if (tags.length === 0) {
+            console.log('No tags found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['tag', 'functions', 'middleware', 'permissions'];
+            const rows = tags.map(([tag, info]) => [
+                tag,
+                String(info.funcIds.length),
+                String(info.middlewareNames.length),
+                String(info.permissionNames.length),
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = ['tag', 'functions', 'middleware', 'permissions'];
+            const rows = tags.map(([tag, info]) => [
+                tag,
+                info.funcIds.join(', ') || '(none)',
+                info.middlewareNames.join(', ') || '(none)',
+                info.permissionNames.join(', ') || '(none)',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoMiddleware = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const definitions = state.middleware?.definitions ?? {};
+        const entries = Object.entries(definitions);
+        if (entries.length === 0) {
+            console.log('No middleware found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['id', 'name', 'exportedName'];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'id',
+                'name',
+                'exportedName',
+                'sourceFile',
+                'services',
+                'description',
+            ];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+                def.sourceFile?.replace(state.rootDir + '/', '') ?? '',
+                def.services?.services?.join(', ') ?? '',
+                def.description ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoPermissions = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const definitions = state.permissions?.definitions ?? {};
+        const entries = Object.entries(definitions);
+        if (entries.length === 0) {
+            console.log('No permissions found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['id', 'name', 'exportedName'];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'id',
+                'name',
+                'exportedName',
+                'sourceFile',
+                'services',
+                'description',
+            ];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+                def.sourceFile?.replace(state.rootDir + '/', '') ?? '',
+                def.services?.services?.join(', ') ?? '',
+                def.description ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});

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

@@ -0,0 +1,34 @@
+export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;