@pikku/core 0.12.19 → 0.12.20

package/CHANGELOG.md

@@ -1,3 +1,69 @@
+## 0.12.20
+
+### Patch Changes
+
+- 18acebe: feat(core): scope bare `rpc.invoke()` calls to the caller's addon package
+
+  Addon functions calling `rpc.invoke('foo')` (bare, no colon) previously only
+  resolved against root RPC meta and threw `RPCNotFoundError` for the addon's
+  own functions, forcing authors to prefix every call with their consumer-facing
+  namespace (`'cli:foo'`) — which couples the addon to its caller's `wireAddon({ name })`.
+
+  `ContextAwareRPCService` now carries an optional `packageName` passed through
+  from `runPikkuFunc` via `getContextRPCService`. For bare names from inside an
+  addon, resolution first checks the caller's package function meta, then falls
+  back to root. Applies to both `rpc.invoke()` and `rpc.rpcWithWire()`. Explicit
+  namespaced calls (`'stripe:createCharge'`) and root-namespace calls are unchanged.
+
+- 66d1b4f: feat(content)!: bucket-aware ContentService with typed object args
+
+  BREAKING CHANGE: All `ContentService` methods now take object args with a
+  required `bucket` field. The interface is generic over `TBucket extends string`
+  so callers can constrain bucket names to a typed union.
+
+  Migration:
+
+  ```ts
+  // Before
+  content.getUploadURL(fileKey, contentType)
+  content.signContentKey(key, expiresAt)
+  content.writeFile(assetKey, stream)
+  content.readFile(assetKey)
+  content.deleteFile(assetKey)
+
+  // After
+  content.getUploadURL({ bucket, fileKey, contentType })
+  content.signContentKey({ bucket, contentKey, dateLessThan: expiresAt })
+  content.writeFile({ bucket, key, stream })
+  content.readFile({ bucket, key })
+  content.deleteFile({ bucket, key })
+  ```
+
+  - New exported types: `SignContentKeyArgs`, `SignURLArgs`, `GetUploadURLArgs`,
+    `UploadURLResult`, `BucketKeyArgs`, `WriteFileArgs`, `CopyFileArgs`.
+  - `LocalContent` stores objects under `<base>/<bucket>/<key>`.
+  - `S3Content` and `B2Content` treat the logical bucket as a key prefix within
+    the configured underlying storage bucket.
+  - `workflow-screenshot` addon takes `bucket?` / `key?` input; default bucket
+    resolved from `PIKKU_WORKFLOW_SCREENSHOT_BUCKET` variable, no hardcoded
+    fallback.
+
+- 3e35b99: feat(core): scope bare workflow names to the caller's addon package
+
+  Parallel to the RPC scoping fix for addon functions. Addon code calling
+  `services.workflowService.runToCompletion('myWorkflow', ...)` (bare name,
+  no colon) previously missed workflows registered under the addon's package
+  scope and threw `WorkflowNotFoundError`, forcing authors to hard-code
+  the consumer-facing namespace (`'cli:myWorkflow'`) — which couples the
+  addon to its caller's `wireAddon({ name })`.
+
+  `getOrCreatePackageSingletonServices` in the function-runner now wraps
+  the package's `workflowService` with a Proxy that auto-prefixes bare
+  workflow names on `startWorkflow` / `runToCompletion` with the addon's
+  consumer-defined namespace (looked up from `pikkuState(null, 'addons',
+'packages')`). Explicit `'ns:name'` calls and root-namespace workflows
+  are unchanged.
+
 ## 0.12.19
 
 ### Patch Changes

package/dist/function/function-runner.js

@@ -37,6 +37,51 @@ async function resolveSession(wire, singletonServices, sessionService) {
  * @param parentServices - The parent/caller's singleton services (used as base)
  * @returns The package's singleton services
  */
+/**
+ * Find the consumer-defined namespace (from wireAddon) for a given addon package.
+ * Returns null if the package isn't registered as an addon.
+ */
+const findAddonNamespaceForPackage = (packageName) => {
+    const addons = pikkuState(null, 'addons', 'packages');
+    if (!addons)
+        return null;
+    for (const [namespace, cfg] of addons.entries()) {
+        if (cfg?.package === packageName)
+            return namespace;
+    }
+    return null;
+};
+/**
+ * Wrap a workflow service so that bare workflow names passed from inside an
+ * addon function are auto-prefixed with the addon's consumer-facing namespace.
+ * Without this, `runToCompletion('myWorkflow')` from inside an addon misses
+ * the workflow registered under the addon's package scope and throws
+ * WorkflowNotFoundError — forcing addons to hardcode their consumer-defined
+ * namespace, which couples the addon to its caller.
+ *
+ * Explicit `'ns:name'` and bare names that already exist in root meta are
+ * unaffected; only bare names that would otherwise miss resolution get
+ * prefixed.
+ */
+const wrapWorkflowServiceForPackage = (service, packageName) => {
+    return new Proxy(service, {
+        get(target, prop, receiver) {
+            if (prop === 'startWorkflow' || prop === 'runToCompletion') {
+                const original = Reflect.get(target, prop, receiver);
+                return function (name, ...rest) {
+                    if (typeof name === 'string' && !name.includes(':')) {
+                        const namespace = findAddonNamespaceForPackage(packageName);
+                        if (namespace) {
+                            name = `${namespace}:${name}`;
+                        }
+                    }
+                    return original.call(this, name, ...rest);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+};
 const getOrCreatePackageSingletonServices = async (packageName, parentServices) => {
     // Check if we already have cached singleton services for this package
     const cachedServices = pikkuState(packageName, 'package', 'singletonServices');
@@ -56,6 +101,12 @@ const getOrCreatePackageSingletonServices = async (packageName, parentServices)
     }
     // Create singleton services for the package, passing parent services as existing
     const packageServices = await factories.createSingletonServices(config, parentServices);
+    // Wrap workflowService so that bare names used inside the addon's functions
+    // resolve to workflows registered under the addon's package scope.
+    if (packageServices.workflowService &&
+        typeof packageServices.workflowService === 'object') {
+        packageServices.workflowService = wrapWorkflowServiceForPackage(packageServices.workflowService, packageName);
+    }
     // Cache the services
     pikkuState(packageName, 'package', 'singletonServices', packageServices);
     return packageServices;
@@ -223,11 +274,10 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
             const services = wireServices && Object.keys(wireServices).length > 0
                 ? { ...resolvedSingletonServices, ...wireServices }
                 : resolvedSingletonServices;
+            const callerPackageName = packageName;
             Object.defineProperty(resolvedWire, 'rpc', {
                 get() {
-                    const rpc = rpcService.getContextRPCService(services, resolvedWire, {
-                        sessionService,
-                    });
+                    const rpc = rpcService.getContextRPCService(services, resolvedWire, { sessionService }, 0, callerPackageName);
                     Object.defineProperty(resolvedWire, 'rpc', {
                         value: rpc,
                         writable: true,

package/dist/index.d.ts

@@ -24,7 +24,7 @@ export type { QueueService } from './wirings/queue/queue.types.js';
 export type { JWTService } from './services/jwt-service.js';
 export type { SecretService } from './services/secret-service.js';
 export type { VariablesService } from './services/variables-service.js';
-export type { ContentService } from './services/content-service.js';
+export type { ContentService, SignContentKeyArgs, SignURLArgs, GetUploadURLArgs, UploadURLResult, BucketKeyArgs, WriteFileArgs, CopyFileArgs, } from './services/content-service.js';
 export type { DeploymentService } from './services/deployment-service.js';
 export type { WorkflowService } from './services/workflow-service.js';
 export type { GatewayService } from './services/gateway-service.js';

package/dist/services/content-service.d.ts

@@ -1,60 +1,89 @@
-export interface ContentService {
+/**
+ * Arguments for signing a content key into a time-limited URL.
+ */
+export interface SignContentKeyArgs<TBucket extends string = string> {
+    bucket: TBucket;
+    contentKey: string;
+    dateLessThan: Date;
+    dateGreaterThan?: Date;
+}
+/**
+ * Arguments for signing an arbitrary URL.
+ */
+export interface SignURLArgs {
+    url: string;
+    dateLessThan: Date;
+    dateGreaterThan?: Date;
+}
+/**
+ * Arguments for minting a presigned upload URL.
+ */
+export interface GetUploadURLArgs<TBucket extends string = string> {
+    bucket: TBucket;
+    fileKey: string;
+    contentType: string;
+    size?: number;
+}
+/**
+ * Result of minting a presigned upload URL.
+ */
+export interface UploadURLResult {
+    uploadUrl: string;
+    assetKey: string;
+    uploadHeaders?: Record<string, string>;
+    uploadMethod?: 'PUT' | 'POST';
+}
+/**
+ * Arguments for an operation that targets a single object by key.
+ */
+export interface BucketKeyArgs<TBucket extends string = string> {
+    bucket: TBucket;
+    key: string;
+}
+/**
+ * Arguments for writing a stream to storage.
+ */
+export interface WriteFileArgs<TBucket extends string = string> extends BucketKeyArgs<TBucket> {
+    stream: ReadableStream | NodeJS.ReadableStream;
+}
+/**
+ * Arguments for copying a local file into storage.
+ */
+export interface CopyFileArgs<TBucket extends string = string> extends BucketKeyArgs<TBucket> {
+    fromAbsolutePath: string;
+}
+export interface ContentService<TBucket extends string = string> {
     /**
      * Signs a content key to generate a secure, time-limited access URL.
-     * @param contentKey - The key representing the content object.
-     * @param dateLessThan - The expiration time for the signed URL.
-     * @param dateGreaterThan - (Optional) Start time before which access is denied.
      */
-    signContentKey(contentKey: string, dateLessThan: Date, dateGreaterThan?: Date): Promise<string>;
+    signContentKey(args: SignContentKeyArgs<TBucket>): Promise<string>;
     /**
      * Signs an arbitrary URL to generate a secure, time-limited access URL.
-     * @param url - The full URL that needs signing.
-     * @param dateLessThan - The expiration time for the signed URL.
-     * @param dateGreaterThan - (Optional) Start time before which access is denied.
      */
-    signURL(url: string, dateLessThan: Date, dateGreaterThan?: Date): Promise<string>;
+    signURL(args: SignURLArgs): Promise<string>;
     /**
      * Generates a signed URL for uploading a file directly to storage.
-     * @param fileKey - The desired key/location of the uploaded file.
-     * @param contentType - The MIME type of the file.
-     * @returns A signed upload URL and the finalized asset key.
+     * Bucket policy (size limits, MIME allowlist) is enforced by the implementation.
      */
-    getUploadURL(fileKey: string, contentType: string): Promise<{
-        uploadUrl: string;
-        assetKey: string;
-        uploadHeaders?: Record<string, string>;
-        uploadMethod?: 'PUT' | 'POST';
-    }>;
+    getUploadURL(args: GetUploadURLArgs<TBucket>): Promise<UploadURLResult>;
     /**
      * Deletes a file from the storage backend.
-     * @param fileName - The name or key of the file to delete.
-     * @returns A boolean indicating success.
      */
-    deleteFile(fileName: string): Promise<boolean>;
+    deleteFile(args: BucketKeyArgs<TBucket>): Promise<boolean>;
     /**
-     * Uploads a file stream to storage under a specified asset key.
-     * @param assetKey - The key where the file will be saved.
-     * @param stream - A readable stream of the file contents.
-     * @returns A boolean indicating success.
+     * Uploads a file stream to storage under the specified bucket + key.
      */
-    writeFile(assetKey: string, stream: ReadableStream | NodeJS.ReadableStream): Promise<boolean>;
+    writeFile(args: WriteFileArgs<TBucket>): Promise<boolean>;
     /**
-     * Copies a file from a local absolute path into storage under a new asset key.
-     * @param assetKey - The destination key.
-     * @param fromAbsolutePath - The local absolute file path.
-     * @returns A boolean indicating success.
+     * Copies a file from a local absolute path into storage.
      */
-    copyFile(assetKey: string, fromAbsolutePath: string): Promise<boolean>;
+    copyFile(args: CopyFileArgs<TBucket>): Promise<boolean>;
     /**
      * Reads a file from storage as a readable stream.
-     * @param assetKey - The key of the file to read.
-     * @returns A readable file stream.
      */
-    readFile(assetKey: string): Promise<ReadableStream | NodeJS.ReadableStream>;
+    readFile(args: BucketKeyArgs<TBucket>): Promise<ReadableStream | NodeJS.ReadableStream>;
     /**
      * Reads an entire file from storage into a Buffer.
-     * @param assetKey - The key of the file to read.
-     * @returns The file contents as a Buffer.
      */
-    readFileAsBuffer(assetKey: string): Promise<Buffer>;
+    readFileAsBuffer(args: BucketKeyArgs<TBucket>): Promise<Buffer>;
 }

package/dist/services/index.d.ts

@@ -16,7 +16,7 @@ export { InMemoryQueueService } from './in-memory-queue-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
 export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
 export { LocalGatewayService } from './local-gateway-service.js';
-export type { ContentService } from './content-service.js';
+export type { ContentService, SignContentKeyArgs, SignURLArgs, GetUploadURLArgs, UploadURLResult, BucketKeyArgs, WriteFileArgs, CopyFileArgs, } from './content-service.js';
 export type { JWTService } from './jwt-service.js';
 export type { Logger } from './logger.js';
 export type { SecretService } from './secret-service.js';

package/dist/services/local-content.d.ts

@@ -1,4 +1,4 @@
-import type { ContentService, JWTService, Logger } from '@pikku/core/services';
+import type { BucketKeyArgs, ContentService, CopyFileArgs, GetUploadURLArgs, JWTService, Logger, SignContentKeyArgs, SignURLArgs, UploadURLResult, WriteFileArgs } from '@pikku/core/services';
 export interface LocalContentConfig {
     localFileUploadPath: string;
     uploadUrlPrefix: string;
@@ -12,18 +12,16 @@ export declare class LocalContent implements ContentService {
     private jwt?;
     constructor(config: LocalContentConfig, logger: Logger, jwt?: JWTService | undefined);
     private safePath;
+    private joinKey;
     init(): Promise<void>;
     private signParams;
-    signURL(url: string, dateLessThan: Date, dateGreaterThan?: Date): Promise<string>;
-    signContentKey(assetKey: string, dateLessThan: Date, dateGreaterThan?: Date): Promise<string>;
-    getUploadURL(assetKey: string): Promise<{
-        uploadUrl: string;
-        assetKey: string;
-    }>;
-    writeFile(assetKey: string, stream: ReadableStream | NodeJS.ReadableStream): Promise<boolean>;
-    copyFile(assetKey: string, fromAbsolutePath: string): Promise<boolean>;
-    readFile(assetKey: string): Promise<ReadableStream | NodeJS.ReadableStream>;
-    readFileAsBuffer(assetKey: string): Promise<Buffer>;
-    deleteFile(assetKey: string): Promise<boolean>;
+    signURL(args: SignURLArgs): Promise<string>;
+    signContentKey(args: SignContentKeyArgs): Promise<string>;
+    getUploadURL(args: GetUploadURLArgs): Promise<UploadURLResult>;
+    writeFile(args: WriteFileArgs): Promise<boolean>;
+    copyFile(args: CopyFileArgs): Promise<boolean>;
+    readFile(args: BucketKeyArgs): Promise<ReadableStream | NodeJS.ReadableStream>;
+    readFileAsBuffer(args: BucketKeyArgs): Promise<Buffer>;
+    deleteFile(args: BucketKeyArgs): Promise<boolean>;
     private createDirectoryForFile;
 }

package/dist/services/local-content.js

@@ -11,14 +11,18 @@ export class LocalContent {
         this.logger = logger;
         this.jwt = jwt;
     }
-    safePath(assetKey) {
+    safePath(bucket, key) {
         const base = resolve(this.config.localFileUploadPath);
-        const target = resolve(base, normalize(assetKey));
+        const scoped = resolve(base, normalize(bucket));
+        const target = resolve(scoped, normalize(key));
         if (!target.startsWith(base + '/') && target !== base) {
             throw new Error('Invalid asset key');
         }
         return target;
     }
+    joinKey(bucket, key) {
+        return `${bucket}/${key}`;
+    }
     async init() { }
     async signParams(dateLessThan, dateGreaterThan) {
         const signedAt = Date.now();
@@ -37,81 +41,86 @@ export class LocalContent {
         }
         return params.toString();
     }
-    async signURL(url, dateLessThan, dateGreaterThan) {
-        const params = await this.signParams(dateLessThan, dateGreaterThan);
-        return `${url}?${params}`;
+    async signURL(args) {
+        const params = await this.signParams(args.dateLessThan, args.dateGreaterThan);
+        return `${args.url}?${params}`;
     }
-    async signContentKey(assetKey, dateLessThan, dateGreaterThan) {
+    async signContentKey(args) {
+        const fullKey = this.joinKey(args.bucket, args.contentKey);
         const base = this.config.server
-            ? `${this.config.server}${this.config.assetUrlPrefix}/${assetKey}`
-            : `${this.config.assetUrlPrefix}/${assetKey}`;
-        return this.signURL(base, dateLessThan, dateGreaterThan);
+            ? `${this.config.server}${this.config.assetUrlPrefix}/${fullKey}`
+            : `${this.config.assetUrlPrefix}/${fullKey}`;
+        return this.signURL({
+            url: base,
+            dateLessThan: args.dateLessThan,
+            dateGreaterThan: args.dateGreaterThan,
+        });
     }
-    async getUploadURL(assetKey) {
-        this.logger.debug(`Going to upload with key: ${assetKey}`);
+    async getUploadURL(args) {
+        const fullKey = this.joinKey(args.bucket, args.fileKey);
+        this.logger.debug(`Going to upload with key: ${fullKey}`);
         return {
-            uploadUrl: `${this.config.uploadUrlPrefix}/${assetKey}`,
-            assetKey,
+            uploadUrl: `${this.config.uploadUrlPrefix}/${fullKey}`,
+            assetKey: fullKey,
         };
     }
-    async writeFile(assetKey, stream) {
-        this.logger.debug(`Writing file: ${assetKey}`);
-        const path = this.safePath(assetKey);
+    async writeFile(args) {
+        this.logger.debug(`Writing file: ${args.bucket}/${args.key}`);
+        const path = this.safePath(args.bucket, args.key);
         try {
             await this.createDirectoryForFile(path);
             const fileStream = createWriteStream(path);
-            // Use pipeline to properly manage stream piping and errors
-            await pipeline(stream, fileStream);
+            await pipeline(args.stream, fileStream);
             return true;
         }
         catch (e) {
             console.error(e);
-            this.logger.error(`Error writing content ${assetKey}`, e);
+            this.logger.error(`Error writing content ${args.bucket}/${args.key}`, e);
             return false;
         }
     }
-    async copyFile(assetKey, fromAbsolutePath) {
-        this.logger.debug(`Writing file: ${assetKey}`);
+    async copyFile(args) {
+        this.logger.debug(`Writing file: ${args.bucket}/${args.key}`);
         try {
-            const path = this.safePath(assetKey);
+            const path = this.safePath(args.bucket, args.key);
             await this.createDirectoryForFile(path);
-            await promises.copyFile(fromAbsolutePath, path);
+            await promises.copyFile(args.fromAbsolutePath, path);
+            return true;
         }
         catch (e) {
             console.error(e);
-            this.logger.error(`Error inserting content ${assetKey}`, e);
+            this.logger.error(`Error inserting content ${args.bucket}/${args.key}`, e);
         }
         return false;
     }
-    async readFile(assetKey) {
-        this.logger.debug(`Getting key: ${assetKey}`);
-        const filePath = this.safePath(assetKey);
+    async readFile(args) {
+        this.logger.debug(`Getting key: ${args.bucket}/${args.key}`);
+        const filePath = this.safePath(args.bucket, args.key);
         try {
             const stream = createReadStream(filePath);
-            // Handle early stream errors (like file not found, permission denied, etc.)
             stream.on('error', (err) => {
-                this.logger.error(`Error getting content ${assetKey}`, err);
+                this.logger.error(`Error getting content ${args.bucket}/${args.key}`, err);
             });
             return stream;
         }
         catch (e) {
-            this.logger.error(`Error setting up stream for ${assetKey}`, e);
+            this.logger.error(`Error setting up stream for ${args.bucket}/${args.key}`, e);
             throw e;
         }
     }
-    async readFileAsBuffer(assetKey) {
-        const filePath = this.safePath(assetKey);
-        this.logger.debug(`Reading file as buffer: ${assetKey}`);
+    async readFileAsBuffer(args) {
+        const filePath = this.safePath(args.bucket, args.key);
+        this.logger.debug(`Reading file as buffer: ${args.bucket}/${args.key}`);
         return readFile(filePath);
     }
-    async deleteFile(assetKey) {
-        this.logger.debug(`deleting key: ${assetKey}`);
+    async deleteFile(args) {
+        this.logger.debug(`deleting key: ${args.bucket}/${args.key}`);
         try {
-            await promises.unlink(this.safePath(assetKey));
+            await promises.unlink(this.safePath(args.bucket, args.key));
             return true;
         }
         catch (e) {
-            this.logger.error(`Error deleting content ${assetKey}`, e);
+            this.logger.error(`Error deleting content ${args.bucket}/${args.key}`, e);
         }
         return false;
     }

package/dist/wirings/rpc/rpc-runner.d.ts

@@ -18,10 +18,11 @@ export declare class ContextAwareRPCService {
     private services;
     private wire;
     private options;
+    private packageName;
     constructor(services: CoreServices, wire: PikkuWire, options: {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    });
+    }, packageName?: string | null);
     rpcExposed(funcName: string, data: any): Promise<any>;
     rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
     /**
@@ -96,7 +97,7 @@ export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = P
     getContextRPCService(services: Services, wire: PikkuWire, requiresAuthOrOptions?: boolean | {
         requiresAuth?: boolean;
         sessionService?: SessionService<CoreUserSession>;
-    } | undefined, depth?: number): TypedRPC;
+    } | undefined, depth?: number, packageName?: string | null): TypedRPC;
 }
 export declare const rpcService: PikkuRPCService<import("../../types/core.types.js").CoreSingletonServices<{
     logLevel?: import("../../services/logger.js").LogLevel;

package/dist/wirings/rpc/rpc-runner.js

@@ -39,7 +39,22 @@ export const resolveNamespace = (namespacedFunction) => {
         addonConfig: pkgConfig,
     };
 };
-const getPikkuFunctionName = (rpcName) => {
+/**
+ * Resolve a bare (non-namespaced) RPC name to its pikkuFuncId, preferring
+ * the caller's addon package when provided. Returns the function name plus
+ * the package scope that resolved it (null = root), so callers can thread
+ * the scope into runPikkuFunc without a second lookup.
+ */
+const resolvePikkuFunction = (rpcName, packageName = null) => {
+    // Addon-scoped calls: try the caller's package function meta first.
+    // (RPC meta only lives in root; addon functions are registered under their package.)
+    if (packageName) {
+        const pkgFunctions = pikkuState(packageName, 'function', 'meta');
+        const pkgMeta = pkgFunctions?.[rpcName];
+        if (pkgMeta) {
+            return { pikkuFuncId: pkgMeta.pikkuFuncId || rpcName, packageName };
+        }
+    }
     const rpc = pikkuState(null, 'rpc', 'meta');
     let rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
@@ -51,17 +66,19 @@ const getPikkuFunctionName = (rpcName) => {
     if (!rpcMeta) {
         throw new RPCNotFoundError(rpcName);
     }
-    return rpcMeta;
+    return { pikkuFuncId: rpcMeta, packageName: null };
 };
 // Context-aware RPC client for use within services
 export class ContextAwareRPCService {
     services;
     wire;
     options;
-    constructor(services, wire, options) {
+    packageName;
+    constructor(services, wire, options, packageName = null) {
         this.services = services;
         this.wire = wire;
         this.options = options;
+        this.packageName = packageName;
     }
     async rpcExposed(funcName, data) {
         let functionMeta;
@@ -105,13 +122,18 @@ export class ContextAwareRPCService {
                 // Not an addon — fall through to local lookup
             }
         }
-        // Try local function, then fall back to deployment service (remote)
+        // Bare name: resolve via caller's package scope first (if any), then root.
+        // Note: intra-addon bare calls do NOT re-apply the addon's external
+        // addonConfig.auth/tags — those gates are only applied on the external
+        // 'namespace:func' boundary via invokeAddonFunction.
         try {
-            return await runPikkuFunc('rpc', funcName, getPikkuFunctionName(funcName), {
+            const resolved = resolvePikkuFunction(funcName, this.packageName);
+            return await runPikkuFunc('rpc', funcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: updatedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -181,11 +203,13 @@ export class ContextAwareRPCService {
             return this.invokeAddonFunction(rpcName, data, mergedWire);
         }
         try {
-            return await runPikkuFunc('rpc', rpcName, getPikkuFunctionName(rpcName), {
+            const resolved = resolvePikkuFunction(rpcName, this.packageName);
+            return await runPikkuFunc('rpc', rpcName, resolved.pikkuFuncId, {
                 auth: this.options.requiresAuth,
                 singletonServices: this.services,
                 data: () => data,
                 wire: mergedWire,
+                packageName: resolved.packageName,
             });
         }
         catch (e) {
@@ -269,12 +293,12 @@ export class ContextAwareRPCService {
 // RPC Service class for the global interface
 export class PikkuRPCService {
     // Convenience function for initializing
-    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0) {
+    getContextRPCService(services, wire, requiresAuthOrOptions, depth = 0, packageName = null) {
         const options = typeof requiresAuthOrOptions === 'object' &&
             requiresAuthOrOptions !== null
             ? requiresAuthOrOptions
             : { requiresAuth: requiresAuthOrOptions };
-        const serviceRPC = new ContextAwareRPCService(services, wire, options);
+        const serviceRPC = new ContextAwareRPCService(services, wire, options, packageName);
         return {
             depth,
             global: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.19",
+  "version": "0.12.20",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",