@pikku/cli 0.12.82 → 0.12.85

package/dist/src/functions/commands/import-n8n.js

@@ -0,0 +1,130 @@
+import { existsSync } from 'fs';
+import { basename, isAbsolute, join, resolve } from 'path';
+import { mkdir, readdir, readFile, stat, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { parseN8n, generateWorkflowFromN8n } from '@pikku/n8n-import';
+async function writeFiles(baseDir, files) {
+    const written = [];
+    for (const [relativePath, content] of Object.entries(files)) {
+        const fullPath = join(baseDir, relativePath);
+        await mkdir(join(fullPath, '..'), { recursive: true });
+        await writeFile(fullPath, content, 'utf-8');
+        written.push(fullPath);
+    }
+    return written;
+}
+// A single n8n export file may hold one workflow object, a bare array of
+// workflows (n8n `export:workflow --all`), or a `{ workflows: [...] }` wrapper.
+// Flatten whichever shape into one job per workflow.
+function collectJobs(raw, nameHint, jobs) {
+    const list = Array.isArray(raw)
+        ? raw
+        : raw && Array.isArray(raw.workflows)
+            ? raw.workflows
+            : null;
+    if (list) {
+        list.forEach((wf, i) => {
+            const own = wf?.name?.trim();
+            jobs.push({ raw: wf, nameHint: own || `${nameHint}-${i + 1}` });
+        });
+    }
+    else {
+        jobs.push({ raw, nameHint });
+    }
+}
+async function importOne({ raw, nameHint }, baseDir, logger) {
+    let parsed;
+    try {
+        parsed = parseN8n(raw, nameHint);
+    }
+    catch (err) {
+        logger.error(`Failed to parse "${nameHint}": ${err.message}`);
+        return false;
+    }
+    const { files, manifest, credentialInstances, diagnostics } = generateWorkflowFromN8n(parsed);
+    // A single-file import can only resolve self-references; any cross-workflow
+    // sub-workflow reference is un-importable here. Report and skip rather than
+    // write a partial, un-runnable scaffold.
+    if (diagnostics.some((d) => d.type === 'error')) {
+        logger.error(`Cannot import "${parsed.name}":`);
+        for (const d of diagnostics) {
+            logger.error(`  [${d.reason}] ${d.message}`);
+        }
+        return false;
+    }
+    const written = await writeFiles(baseDir, files);
+    logger.info(`Imported "${parsed.name}" (${parsed.shape}) → ${written.length} file(s) in ${baseDir}`);
+    if (manifest.length > 0) {
+        logger.info(`  ${manifest.length} integration node(s) recorded in ${parsed.slug}.integrations.json`);
+    }
+    if (credentialInstances.length > 0) {
+        logger.info(`  ${credentialInstances.length} addon instance(s) wired in ${parsed.slug}.addons.gen.ts: ${credentialInstances
+            .map((i) => i.instanceName)
+            .join(', ')}`);
+    }
+    const stubCount = written.filter((f) => f.includes('/functions/')).length;
+    if (stubCount > 0) {
+        logger.info(`  ${stubCount} stub function(s) to implement — run the pikku-n8n-import skill to fill them in`);
+    }
+    return true;
+}
+export const pikkuImportN8n = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { file, out }) => {
+        const inputPath = isAbsolute(file) ? file : resolve(process.cwd(), file);
+        if (!existsSync(inputPath)) {
+            logger.error(`n8n workflow file not found: ${inputPath}`);
+            process.exit(1);
+        }
+        const baseDir = out
+            ? isAbsolute(out)
+                ? out
+                : resolve(process.cwd(), out)
+            : config.scaffold?.functionDir || process.cwd();
+        const jobs = [];
+        if ((await stat(inputPath)).isDirectory()) {
+            const entries = (await readdir(inputPath))
+                .filter((f) => f.toLowerCase().endsWith('.json'))
+                .sort();
+            if (entries.length === 0) {
+                logger.error(`No .json workflow files found in ${inputPath}`);
+                process.exit(1);
+            }
+            for (const entry of entries) {
+                try {
+                    const raw = JSON.parse(await readFile(join(inputPath, entry), 'utf-8'));
+                    collectJobs(raw, entry.replace(/\.json$/i, ''), jobs);
+                }
+                catch (err) {
+                    logger.error(`Failed to read ${entry}: ${err.message}`);
+                }
+            }
+        }
+        else {
+            let raw;
+            try {
+                raw = JSON.parse(await readFile(inputPath, 'utf-8'));
+            }
+            catch (err) {
+                logger.error(`Failed to parse n8n workflow: ${err.message}`);
+                process.exit(1);
+            }
+            collectJobs(raw, basename(inputPath).replace(/\.json$/i, ''), jobs);
+        }
+        if (jobs.length === 0) {
+            logger.error('No workflows found to import');
+            process.exit(1);
+        }
+        let failed = 0;
+        for (const job of jobs) {
+            if (!(await importOne(job, baseDir, logger)))
+                failed++;
+        }
+        if (jobs.length > 1) {
+            const ok = jobs.length - failed;
+            logger.info(`Imported ${ok}/${jobs.length} workflow(s) into ${baseDir}${failed > 0 ? ` — ${failed} failed` : ''}`);
+        }
+        if (failed > 0) {
+            process.exit(1);
+        }
+    },
+});

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, "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 declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};

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

@@ -159,19 +159,6 @@ export const pikkuInfoTags = pikkuSessionlessFunc({
                 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.');

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

@@ -11,7 +11,7 @@ interface LoginOptions {
  * `~/.pikku/session.json`; generated CLI/websocket clients pick it up
  * automatically.
  */
-export declare const login: import("#pikku").PikkuFunctionConfig<LoginOptions, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<LoginOptions, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<LoginOptions, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const login: import("#pikku").PikkuFunctionConfig<LoginOptions, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * `pikku logout` — remove a stored session (the given `--url`, or the current
  * default).
@@ -20,9 +20,9 @@ export declare const logout: import("#pikku").PikkuFunctionConfig<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * `pikku whoami` — show the current (or `--url`) stored session and whether it
  * has expired.
@@ -31,7 +31,7 @@ export declare const whoami: import("#pikku").PikkuFunctionConfig<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};

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

@@ -1,56 +1,56 @@
-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 pikkuMetaFunctionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaSchemasList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWorkflowsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaMiddlewareList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaPermissionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, 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<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | 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>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresHttp: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresScheduler: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresQueue: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresChannel: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * Bulk context endpoint.
  *
@@ -63,7 +63,7 @@ export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig
  * 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>;
+export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * Frontend-targeted metadata.
  *
@@ -79,4 +79,4 @@ export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{},
  * 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>;
+export declare const pikkuMetaClients: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

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

@@ -1,3 +1,14 @@
+/**
+ * Pick the protocol the generated test app uses to depend on its parent addon.
+ *
+ * Inside a workspace this must be `workspace:*`. The `file:` protocol copies
+ * the whole parent directory rather than honouring its `files` field, so the
+ * copy includes the parent's own test/node_modules — which already holds a
+ * copy. Every install then adds another layer until the path exceeds the OS
+ * limit. Outside a workspace `workspace:*` cannot resolve, so `file:` remains
+ * the only option there.
+ */
+export declare function resolveAddonDepProtocol(baseDir: string): string;
 export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     name: string;
     displayName?: string;
@@ -28,7 +39,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     name: string;
     displayName?: string;
     description?: string;
@@ -43,4 +54,4 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

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

@@ -1,9 +1,42 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
 import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 import { pikkuSessionlessFunc } from '#pikku';
 import { parseOpenAPISpec, computeContractHash, generateAddonFromOpenAPI, loadAuthConfig, } from '@pikku/openapi-parser';
+/**
+ * Pick the protocol the generated test app uses to depend on its parent addon.
+ *
+ * Inside a workspace this must be `workspace:*`. The `file:` protocol copies
+ * the whole parent directory rather than honouring its `files` field, so the
+ * copy includes the parent's own test/node_modules — which already holds a
+ * copy. Every install then adds another layer until the path exceeds the OS
+ * limit. Outside a workspace `workspace:*` cannot resolve, so `file:` remains
+ * the only option there.
+ */
+export function resolveAddonDepProtocol(baseDir) {
+    let dir = baseDir;
+    while (true) {
+        const manifest = join(dir, 'package.json');
+        if (existsSync(manifest)) {
+            try {
+                const { workspaces } = JSON.parse(readFileSync(manifest, 'utf8'));
+                if (Array.isArray(workspaces) || Array.isArray(workspaces?.packages)) {
+                    return 'workspace:*';
+                }
+            }
+            catch {
+                // A malformed manifest tells us nothing about the workspace layout;
+                // keep walking up rather than failing the scaffold.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            return 'file:..';
+        }
+        dir = parent;
+    }
+}
 function toCamelCase(str) {
     return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
@@ -227,18 +260,28 @@ export const createWireServices = pikkuAddonWireServices(
 `;
     }
     else if (flags.oauth || flags.credential === 'oauth2') {
+        // The OAuth2 access token is owned and refreshed by the platform credential
+        // service (better-auth). Resolve a ready token per-request via the wire and
+        // hand it to the service — the addon does not do its own token exchange.
         files['src/services.ts'] =
-            `import { ${pascalName}Service } from './${name}-api.service.js'
-import { pikkuAddonServices } from '#pikku'
+            `import { UnauthorizedError } from '@pikku/core/errors'
+import { ${pascalName}Service } from './${name}-api.service.js'
+import { pikkuAddonWireServices } from '#pikku'
 
-export const createSingletonServices = pikkuAddonServices(async (
-  config,
-  { secrets, variables }
-) => {
-  const ${camelName} = new ${pascalName}Service(secrets, variables)
+export const createWireServices = pikkuAddonWireServices(
+  async ({ variables }, wire) => {
+    if (!wire.getCredential) {
+      throw new Error('Credential resolution is not available in this runtime')
+    }
+    const cred = await wire.getCredential<{ accessToken: string }>('${camelName}')
+    if (!cred?.accessToken) {
+      throw new UnauthorizedError('No ${displayName} connection — connect ${displayName} first')
+    }
+    const ${camelName} = new ${pascalName}Service(cred, variables)
 
-  return { ${camelName} }
-})
+    return { ${camelName} }
+  }
+)
 `;
     }
     else if (flags.secret) {
@@ -329,41 +372,30 @@ export class ${pascalName}Service {
 `;
     }
     else if (flags.oauth) {
+        // The access token is resolved (and refreshed) by the platform credential
+        // service and injected via createWireServices — this service just uses it.
         files[`src/${name}-api.service.ts`] =
-            `import { OAuth2Client } from '@pikku/core/oauth2'
-import type { TypedSecretService } from '#pikku/secrets/pikku-secrets.gen.js'
+            `import type { TypedVariablesService } from '#pikku/variables/pikku-variables.gen.js'
 
 const BASE_URL = 'https://api.example.com/v1'
 
-export const ${screamingName}_OAUTH2_CONFIG = {
-  tokenSecretId: '${screamingName}_TOKENS',
-  authorizationUrl: 'https://example.com/oauth2/authorize',
-  tokenUrl: 'https://example.com/oauth2/token',
-  scopes: ['read', 'write'],
-}
-
 export interface RequestOptions {
   body?: unknown
   qs?: Record<string, string | number | boolean | undefined>
 }
 
 export class ${pascalName}Service {
-  private oauth: OAuth2Client
-
-  constructor(secrets: TypedSecretService) {
-    this.oauth = new OAuth2Client(
-      ${screamingName}_OAUTH2_CONFIG,
-      '${screamingName}_APP_CREDENTIALS',
-      secrets
-    )
-  }
+  constructor(
+    private creds: { accessToken: string },
+    _variables?: TypedVariablesService
+  ) {}
 
   async request<T>(
     method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
     endpoint: string,
     options?: RequestOptions
   ): Promise<T> {
-    const url = new URL(\`\${BASE_URL}\${endpoint}\`)
+    const url = new URL(endpoint, BASE_URL)
 
     if (options?.qs) {
       for (const [key, value] of Object.entries(options.qs)) {
@@ -373,10 +405,11 @@ export class ${pascalName}Service {
       }
     }
 
-    const response = await this.oauth.request(url.toString(), {
+    const response = await fetch(url.toString(), {
       method,
       headers: {
         'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${this.creds.accessToken}\`,
       },
       body: options?.body ? JSON.stringify(options.body) : undefined,
     })
@@ -386,11 +419,7 @@ export class ${pascalName}Service {
       throw new Error(\`${displayName} API error (\${response.status}): \${errorText}\`)
     }
 
-    const text = await response.text()
-    if (!text) {
-      return {} as T
-    }
-    return JSON.parse(text) as T
+    return response.json() as Promise<T>
   }
 }
 `;
@@ -630,7 +659,7 @@ wireVariable({
     return files;
 }
 function getTestFiles(vars) {
-    const { name, camelName, pascalName, screamingName } = vars;
+    const { name, camelName, pascalName, screamingName, addonDepProtocol } = vars;
     const files = {};
     // test/package.json
     files['package.json'] = JSON.stringify({
@@ -647,7 +676,7 @@ function getTestFiles(vars) {
         },
         dependencies: {
             '@pikku/core': '*',
-            [`@pikku/addon-${name}`]: 'file:..',
+            [`@pikku/addon-${name}`]: addonDepProtocol,
         },
         devDependencies: {
             '@pikku/cli': '*',
@@ -811,7 +840,9 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
         const resolvedDescription = description || `${resolvedDisplayName} integration for Pikku`;
         // Resolve target directory
         const baseDir = dir || config.scaffold?.addonDir || process.cwd();
-        const addonDir = join(baseDir, name);
+        // Folder mirrors the package name (@pikku/addon-<name>) so a packages/
+        // listing reads as packages/addon-<name>, distinct from app workspaces.
+        const addonDir = join(baseDir, `addon-${name}`);
         if (existsSync(addonDir)) {
             logger.error(`Directory already exists: ${addonDir}`);
             process.exit(1);
@@ -824,6 +855,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
             displayName: resolvedDisplayName,
             description: resolvedDescription,
             category,
+            addonDepProtocol: resolveAddonDepProtocol(baseDir),
         };
         // Load the auth config (custom auth header / delegated login overrides)
         let loadedAuthConfig;

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

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

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

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

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

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

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

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

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

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

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

@@ -9,6 +9,12 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
         const addonBootstraps = [];
         for (const [, decl] of stateBeforeBootstrap.rpc?.wireAddonDeclarations ??
             []) {
+            // Remote addons (wireRemoteAddon) run on the host — never import their
+            // runtime bootstrap here; that would register their functions locally
+            // and drag in the runtime deps remote consumption exists to avoid. The
+            // consumer's own wireRemoteAddon() call registers the remote binding.
+            if (decl.remote)
+                continue;
             addonBootstraps.push(`${decl.package}/.pikku/pikku-bootstrap.gen.js`);
             logger.debug(`• Addon bootstrap: ${decl.package}`);
         }

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

@@ -1 +1 @@
-export declare const pikkuSummary: 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 pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-export declare const scenarioList: 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 scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
@@ -9,9 +9,9 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     flows?: string;
     tags?: string;
     coverage?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     environment: string;
     flows?: string;
     tags?: string;
     coverage?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scopes-audit.d.ts

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