@kodycodes/cli 1.18.0 → 1.19.0

package/README.md

@@ -85,7 +85,8 @@ keychain credentials migrate silently into the multi-org store as the active org
 | `kody whoami` | Confirms the CLI MCP connection and lists tools. With a scoped API token (and no login), shows token identity via the Open API. |
 | `kody search [query]` | Calls Kody `search` from the CLI (prefer the host MCP tool). Token-only auth uses Open API `GET /v1/search`. |
 | `kody api <operationId>` | Thin Open API wrapper matching the MCP `api` tool: `operationId` + flat `--params` JSON. Auth: `--token` / `KODY_API_TOKEN` / stored `auth bootstrap` token. The parsed `/openapi.json` route map is cached under the Kody cache dir keyed by the document's `ETag` and revalidated with `If-None-Match` on each run. |
-| `kody execute` | Calls Kody `execute` from the CLI (`--invoke`, `--code`, `--file`, or stdin via `--file -`). With a scoped API token and no login (or with `--token`), cloud execute goes through CapabilityProxy → `kody.execute` — no `kody login`. Add `--local` to run the module (and static `kody:@…` package modules) on this machine instead. `--credential key=name` (repeatable; `org:name` / `personal:name` / empty `=` for none) picks ADR 0068 credentials for `--local` or a `kody login` MCP session. `--allow-private-network` opts local execution into private and local network access. |
+| `kody execute` | Calls Kody `execute` from the CLI (`--invoke`, `--code`, `--file`, or stdin via `--file -`). With a scoped API token and no login (or with `--token`), cloud execute goes through CapabilityProxy → `kody.execute` — no `kody login`. Add `--local` to run the module (and static `kody:@…` package modules) on this machine instead. `--credential key=name` (repeatable; `org:name` / `personal:name` / empty `=` for none) picks ADR 0068 credentials for `--local` or a `kody login` MCP session. `--allow-private-network` opts local execution into private and local network access. `--target prod\|mock` (default `prod`) sends CapabilityProxy / search hops to prod or the built-in CLI mock; `--target mock` implies local workerd. |
+| `kody dev` | Local testing for unpublished packages. Serves `kody.app.entry` on localhost via workerd with hot reload. Subcommands: `fetch`, `job`, `webhook`, `emit`, `check`. Default `--target mock` (scratch storage, fake credentials). Covers exports, webhooks, schedules (run-once), and subscriptions. See [Local package testing](#local-package-testing-kody-dev). |
 
 `--json` prints structured MCP results.
 
@@ -204,6 +205,37 @@ config helpers, revokes and deletes the stored API token; leaves login alone).
 Push moves live HEAD only (packages do not auto-publish). Existing `kody login`
 / `auth bootstrap` flows are unchanged.
 
+## Local package testing (`kody dev`)
+
+Test an unpublished package (app, exports, jobs, webhooks, subscriptions)
+before publish. Bundling reuses the same esbuild path as `execute --file` /
+publish (`local-bundle.ts`). One shared flag:
+
+| Command | `--target prod` (default for execute/search) | `--target mock` (default for `kody dev`) |
+| --- | --- | --- |
+| `kody dev` | Local app against real Kody | Local app against the CLI mock |
+| `execute` / `search` | Real capabilities, storage, secrets | Mock catalog / scratch storage / fake credentials |
+
+The mock is built into the CLI (no kody-celld). It refuses unimplemented routes
+with `not_implemented_in_mock` rather than faking success. `--reset-storage`
+wipes the mock session's scratch store. Share previews are out of scope;
+`execute --local` behavior is unchanged when `--target` is omitted (prod).
+
+```bash
+cd ./my-package
+kody dev                         # serve kody.app.entry; hot reload; --target mock
+kody dev fetch /health           # agent-friendly HTTP probe
+kody dev job heartbeat           # run a declared job once (never schedules locally)
+kody dev webhook ping --body ./fixture.json
+kody dev emit demo.event --body ./event.json   # subscription delivery shape
+kody dev check                   # bundle + light publish validations
+
+# Four surfaces against mock then prod:
+kody execute --target mock --invoke ./greet --params '{"name":"kent"}'
+kody execute --target prod --invoke ./greet --params '{"name":"kent"}'
+kody search --target mock local
+```
+
 ## Local execute
 
 `kody execute --local` runs the same execute module (default export called

package/dist/cli.d.ts

@@ -3,7 +3,7 @@ import { type CredentialCallMapInput } from './credential-call-map.js';
 export { readApiToken, requireApiToken as resolveApiToken, resolveScopedApiToken, } from './api-token.js';
 export { resolveLocalExecuteBearer } from './local-execute-auth.js';
 export { authBootstrap, authBootstrapWithScopes, bootstrapRedeemRequestBody, cliTokenLifetimeAliases, cliTokenLifetimeMissingError, cliTokenLifetimePolicy, parseCliLifetimeSecondsFlag, parseCliScopesFlag, redeemBootstrapCode, resolveCliTokenLifetime, } from './auth-bootstrap.js';
-export type CommandName = 'login' | 'logout' | 'org' | 'status' | 'auth' | 'git-credential' | 'whoami' | 'search' | 'api' | 'execute' | 'install' | 'skill' | 'help' | 'version';
+export type CommandName = 'login' | 'logout' | 'org' | 'status' | 'auth' | 'git-credential' | 'whoami' | 'search' | 'api' | 'execute' | 'dev' | 'install' | 'skill' | 'help' | 'version';
 export declare function apiUrlFrom(values: {
     apiUrl?: string;
 }, env?: NodeJS.ProcessEnv): string;
@@ -35,6 +35,12 @@ declare function parseKnown(args: Array<string>): {
         project?: string | boolean | undefined;
         'no-browser'?: string | boolean | undefined;
         org?: string | boolean | undefined;
+        target?: string | boolean | undefined;
+        'reset-storage'?: string | boolean | undefined;
+        port?: string | boolean | undefined;
+        'app-base-path'?: string | boolean | undefined;
+        method?: string | boolean | undefined;
+        body?: string | boolean | undefined;
         clients?: string | boolean | undefined;
         yes?: string | boolean | undefined;
     };

package/dist/cli.js

@@ -24,6 +24,7 @@ const orgScopedCommands = new Set([
     'search',
     'api',
     'execute',
+    'dev',
     'auth',
 ]);
 function mcpUrlFrom(values) {
@@ -62,6 +63,12 @@ function parseKnown(args) {
             project: { type: 'boolean' },
             'no-browser': { type: 'boolean' },
             org: { type: 'string' },
+            target: { type: 'string' },
+            'reset-storage': { type: 'boolean' },
+            port: { type: 'string' },
+            'app-base-path': { type: 'string' },
+            method: { type: 'string' },
+            body: { type: 'string' },
             clients: { type: 'string' },
             yes: { type: 'boolean', short: 'y' },
         },
@@ -89,6 +96,7 @@ export function resolveCommand(argv) {
         case 'search':
         case 'api':
         case 'execute':
+        case 'dev':
         case 'install':
         case 'skill':
         case 'help':
@@ -145,8 +153,15 @@ async function dispatch(parsed, write, writeErr) {
     });
     const json = parsed.values.json === true;
     if (parsed.values['allow-private-network'] === true &&
+        parsed.command !== 'dev' &&
         (parsed.command !== 'execute' || parsed.values.local !== true)) {
-        throw new Error('--allow-private-network can only be used with execute --local.');
+        throw new Error('--allow-private-network can only be used with execute --local or kody dev.');
+    }
+    if (parsed.values['reset-storage'] === true &&
+        parsed.command !== 'dev' &&
+        parsed.command !== 'execute' &&
+        parsed.command !== 'search') {
+        throw new Error('`--reset-storage` is only used with --target mock on execute, search, or dev.');
     }
     const orgFlag = typeof parsed.values.org === 'string' ? parsed.values.org : undefined;
     if (orgFlag !== undefined && !orgScopedCommands.has(parsed.command)) {
@@ -441,63 +456,110 @@ async function dispatch(parsed, write, writeErr) {
             return 0;
         }
         case 'search': {
+            const { resolveTarget } = await import('./target.js');
+            const target = resolveTarget({
+                command: 'search',
+                flag: typeof parsed.values.target === 'string' ? parsed.values.target : undefined,
+            });
             const query = parsed.positionals.join(' ').trim();
             const tokenValues = tokenFlagValues(parsed.values);
-            const apiUrl = apiUrlFrom({
+            let apiUrl = apiUrlFrom({
                 apiUrl: typeof parsed.values['api-url'] === 'string'
                     ? parsed.values['api-url']
                     : undefined,
             });
-            if (shouldUseApiToken({
-                tokenValues,
-                mcpUrl,
-                apiUrl,
-                allowEnvWithoutLogin: true,
-                ...(org ? { org } : {}),
-            })) {
-                const { searchWithApiToken } = await import('./open-api-client.js');
-                const result = await searchWithApiToken({
-                    token: requireApiToken(tokenValues, process.env, 'search', { apiUrl }),
+            let closeMock;
+            try {
+                if (target === 'mock') {
+                    const { ensureMockTarget } = await import('./mock/mock-server.js');
+                    const mock = await ensureMockTarget({
+                        resetStorage: parsed.values['reset-storage'] === true,
+                    });
+                    apiUrl = mock.apiUrl;
+                    closeMock = mock.started ? () => mock.server.close() : undefined;
+                    const { searchWithApiToken } = await import('./open-api-client.js');
+                    const result = await searchWithApiToken({
+                        token: mock.token,
+                        apiUrl,
+                        query: query || undefined,
+                        entity: typeof parsed.values.entity === 'string'
+                            ? parsed.values.entity
+                            : undefined,
+                        domain: typeof parsed.values.domain === 'string'
+                            ? parsed.values.domain
+                            : undefined,
+                        limit: typeof parsed.values.limit === 'string'
+                            ? Number(parsed.values.limit)
+                            : undefined,
+                    });
+                    write(formatToolResult(result, json));
+                    return result.isError ? 1 : 0;
+                }
+                if (shouldUseApiToken({
+                    tokenValues,
+                    mcpUrl,
                     apiUrl,
+                    allowEnvWithoutLogin: true,
+                    ...(org ? { org } : {}),
+                })) {
+                    const { searchWithApiToken } = await import('./open-api-client.js');
+                    const result = await searchWithApiToken({
+                        token: requireApiToken(tokenValues, process.env, 'search', { apiUrl }),
+                        apiUrl,
+                        ...(org ? { org } : {}),
+                        query: query || undefined,
+                        entity: typeof parsed.values.entity === 'string'
+                            ? parsed.values.entity
+                            : undefined,
+                        domain: typeof parsed.values.domain === 'string'
+                            ? parsed.values.domain
+                            : undefined,
+                        limit: typeof parsed.values.limit === 'string'
+                            ? Number(parsed.values.limit)
+                            : undefined,
+                    });
+                    write(formatToolResult(result, json));
+                    return result.isError ? 1 : 0;
+                }
+                const args = {};
+                if (query)
+                    args.query = query;
+                if (typeof parsed.values.entity === 'string')
+                    args.entity = parsed.values.entity;
+                if (typeof parsed.values.domain === 'string')
+                    args.domain = parsed.values.domain;
+                if (typeof parsed.values.limit === 'string')
+                    args.limit = Number(parsed.values.limit);
+                const { callKodyTool } = await import('./mcp.js');
+                const result = await callKodyTool({
+                    name: 'search',
+                    args,
+                    mcpUrl,
                     ...(org ? { org } : {}),
-                    query: query || undefined,
-                    entity: typeof parsed.values.entity === 'string' ? parsed.values.entity : undefined,
-                    domain: typeof parsed.values.domain === 'string' ? parsed.values.domain : undefined,
-                    limit: typeof parsed.values.limit === 'string'
-                        ? Number(parsed.values.limit)
-                        : undefined,
                 });
                 write(formatToolResult(result, json));
                 return result.isError ? 1 : 0;
             }
-            const args = {};
-            if (query)
-                args.query = query;
-            if (typeof parsed.values.entity === 'string')
-                args.entity = parsed.values.entity;
-            if (typeof parsed.values.domain === 'string')
-                args.domain = parsed.values.domain;
-            if (typeof parsed.values.limit === 'string')
-                args.limit = Number(parsed.values.limit);
-            const { callKodyTool } = await import('./mcp.js');
-            const result = await callKodyTool({
-                name: 'search',
-                args,
-                mcpUrl,
-                ...(org ? { org } : {}),
-            });
-            write(formatToolResult(result, json));
-            return result.isError ? 1 : 0;
+            finally {
+                await closeMock?.();
+            }
         }
         case 'execute': {
+            const { resolveTarget } = await import('./target.js');
+            const target = resolveTarget({
+                command: 'execute',
+                flag: typeof parsed.values.target === 'string' ? parsed.values.target : undefined,
+            });
             const invoke = typeof parsed.values.invoke === 'string' ? parsed.values.invoke : undefined;
             const hasCodeFlag = typeof parsed.values.code === 'string';
             const hasFileFlag = typeof parsed.values.file === 'string';
             const positionalModule = parsed.positionals.join('\n').trim();
-            const local = parsed.values.local === true;
+            // --target mock always runs locally against the CLI mock (no cloud sandbox).
+            const local = parsed.values.local === true || target === 'mock';
             const tokenValues = tokenFlagValues(parsed.values);
-            if (local && invoke !== undefined) {
-                throw new Error('--invoke runs a saved package export in Kody; --local runs a module you provide (--code, --file, or a module string).');
+            const localPackageInvoke = invoke !== undefined ? await tryResolveLocalPackageInvoke(invoke) : null;
+            if (local && invoke !== undefined && !localPackageInvoke) {
+                throw new Error('--invoke runs a saved package export in Kody; --local runs a module you provide (--code, --file, or a module string). To test an unpublished package export, pass an export key from package.json#exports (e.g. `--invoke ./on-user-deleted`) from the package directory, or use --file.');
             }
             if (executeSourcesConflict({ invoke, hasCodeFlag, hasFileFlag, positionalModule })) {
                 throw new Error('--invoke cannot be combined with --code, --file, or a module string.');
@@ -506,23 +568,26 @@ async function dispatch(parsed, write, writeErr) {
                 assertLocalExecuteNodeEngine();
             const fileArg = hasFileFlag ? parsed.values.file : undefined;
             // `--code` wins over `--file`. Only attribute the path when the file is the source.
-            const modulePath = !hasCodeFlag && fileArg !== undefined && fileArg !== '-' ? fileArg : undefined;
-            const code = invoke !== undefined
+            const modulePath = localPackageInvoke?.modulePath ??
+                (!hasCodeFlag && fileArg !== undefined && fileArg !== '-' ? fileArg : undefined);
+            const code = invoke !== undefined && !localPackageInvoke
                 ? undefined
                 : hasCodeFlag
                     ? parsed.values.code
-                    : modulePath !== undefined
+                    : modulePath !== undefined && !localPackageInvoke
                         ? await readFile(modulePath, 'utf8')
-                        : fileArg === '-'
-                            ? await readStdin()
-                            : positionalModule || undefined;
+                        : localPackageInvoke
+                            ? await readFile(localPackageInvoke.modulePath, 'utf8')
+                            : fileArg === '-'
+                                ? await readStdin()
+                                : positionalModule || undefined;
             const credentials = parseCredentialFlags(Array.isArray(parsed.values.credential)
                 ? parsed.values.credential.filter((value) => typeof value === 'string')
                 : typeof parsed.values.credential === 'string'
                     ? [parsed.values.credential]
                     : undefined);
             const args = buildExecuteToolArgs({
-                invoke,
+                invoke: localPackageInvoke ? undefined : invoke,
                 code: typeof code === 'string' ? code : undefined,
                 paramsJson: typeof parsed.values.params === 'string' ? parsed.values.params : undefined,
                 conversationId: typeof parsed.values['conversation-id'] === 'string'
@@ -530,57 +595,215 @@ async function dispatch(parsed, write, writeErr) {
                     : undefined,
                 credentials,
             });
-            const apiUrl = apiUrlFrom({
+            let apiUrl = apiUrlFrom({
                 apiUrl: typeof parsed.values['api-url'] === 'string'
                     ? parsed.values['api-url']
                     : undefined,
             });
-            const useToken = local ||
-                shouldUseApiToken({
-                    tokenValues,
-                    mcpUrl,
-                    apiUrl,
-                    allowEnvWithoutLogin: true,
-                    ...(org ? { org } : {}),
-                });
-            const result = local
-                ? await (await import('./local-execute.js')).runLocalExecute({
-                    code: args.code,
-                    ...(modulePath !== undefined ? { modulePath } : {}),
-                    params: args.params,
-                    conversationId: args.conversationId,
-                    ...(credentials !== undefined ? { credentials } : {}),
-                    token: await resolveLocalExecuteBearer({
+            let closeMock;
+            let mockToken;
+            try {
+                if (target === 'mock') {
+                    const { ensureMockTarget } = await import('./mock/mock-server.js');
+                    const mock = await ensureMockTarget({
+                        resetStorage: parsed.values['reset-storage'] === true,
+                        packageId: localPackageInvoke
+                            ? `local:${localPackageInvoke.kodyId}`
+                            : undefined,
+                    });
+                    apiUrl = mock.apiUrl;
+                    mockToken = mock.token;
+                    closeMock = mock.started ? () => mock.server.close() : undefined;
+                }
+                if (localPackageInvoke) {
+                    const { buildLocalPackageContext, runLocalPackageModule } = await import('./local-package-run.js');
+                    const result = await runLocalPackageModule({
+                        modulePath: localPackageInvoke.modulePath,
+                        params: args.params,
+                        token: mockToken ??
+                            (await resolveLocalExecuteBearer({
+                                tokenValues,
+                                mcpUrl,
+                                apiUrl,
+                                purpose: 'execute local package export',
+                                ...(org ? { org } : {}),
+                            })),
+                        apiUrl,
+                        target,
+                        packageContext: buildLocalPackageContext({
+                            kodyId: localPackageInvoke.kodyId,
+                            hostedUrl: 'http://127.0.0.1:0',
+                        }),
+                        allowPrivateNetwork: parsed.values['allow-private-network'] === true,
+                        onStatus: (message) => writeErr(`${message}\n`),
+                    });
+                    write(formatToolResult(result, json));
+                    return result.isError ? 1 : 0;
+                }
+                const useToken = local ||
+                    shouldUseApiToken({
                         tokenValues,
                         mcpUrl,
                         apiUrl,
-                        purpose: 'execute --local',
+                        allowEnvWithoutLogin: true,
                         ...(org ? { org } : {}),
-                    }),
-                    apiUrl,
-                    ...(org ? { org } : {}),
-                    allowPrivateNetwork: parsed.values['allow-private-network'] === true,
-                    onStatus: (message) => writeErr(`${message}\n`),
-                })
-                : useToken
-                    ? await (await import('./remote-execute.js')).runRemoteExecuteWithToken({
-                        code: typeof args.code === 'string' ? args.code : undefined,
-                        invoke,
+                    });
+                const result = local
+                    ? await (await import('./local-execute.js')).runLocalExecute({
+                        code: args.code,
+                        ...(modulePath !== undefined ? { modulePath } : {}),
                         params: args.params,
                         conversationId: args.conversationId,
                         ...(credentials !== undefined ? { credentials } : {}),
-                        token: requireApiToken(tokenValues, process.env, 'execute with an API token', { apiUrl }),
+                        token: mockToken ??
+                            (await resolveLocalExecuteBearer({
+                                tokenValues,
+                                mcpUrl,
+                                apiUrl,
+                                purpose: 'execute --local',
+                                ...(org ? { org } : {}),
+                            })),
                         apiUrl,
                         ...(org ? { org } : {}),
+                        allowPrivateNetwork: parsed.values['allow-private-network'] === true,
+                        onStatus: (message) => writeErr(`${message}\n`),
                     })
-                    : await (await import('./mcp.js')).callKodyTool({
-                        name: 'execute',
-                        args,
-                        mcpUrl,
-                        ...(org ? { org } : {}),
+                    : useToken
+                        ? await (await import('./remote-execute.js')).runRemoteExecuteWithToken({
+                            code: typeof args.code === 'string' ? args.code : undefined,
+                            invoke,
+                            params: args.params,
+                            conversationId: args.conversationId,
+                            ...(credentials !== undefined ? { credentials } : {}),
+                            token: requireApiToken(tokenValues, process.env, 'execute with an API token', { apiUrl }),
+                            apiUrl,
+                            ...(org ? { org } : {}),
+                        })
+                        : await (await import('./mcp.js')).callKodyTool({
+                            name: 'execute',
+                            args,
+                            mcpUrl,
+                            ...(org ? { org } : {}),
+                        });
+                write(formatToolResult(result, json));
+                return result.isError ? 1 : 0;
+            }
+            finally {
+                await closeMock?.();
+            }
+        }
+        case 'dev': {
+            const { resolveTarget } = await import('./target.js');
+            const { parseDevSubcommand, resolveDevAuth, runDevCheck, runDevEmit, runDevFetch, runDevJob, runDevServe, runDevWebhook, } = await import('./dev-command.js');
+            const target = resolveTarget({
+                command: 'dev',
+                flag: typeof parsed.values.target === 'string' ? parsed.values.target : undefined,
+            });
+            const { subcommand, rest } = parseDevSubcommand(parsed.positionals);
+            const tokenValues = tokenFlagValues(parsed.values);
+            const prodApiUrl = apiUrlFrom({
+                apiUrl: typeof parsed.values['api-url'] === 'string'
+                    ? parsed.values['api-url']
+                    : undefined,
+            });
+            const io = { stdout: write, stderr: writeErr };
+            const bodyPath = typeof parsed.values.body === 'string' ? parsed.values.body : undefined;
+            // `check` only bundles + validates the package tree; it never talks to
+            // mock/prod, so skip auth (and the mock server) to avoid leaking a listen
+            // handle that would keep the process alive after printing results.
+            if (subcommand === 'check') {
+                return await runDevCheck({ target, json, io });
+            }
+            const token = target === 'prod'
+                ? await resolveLocalExecuteBearer({
+                    tokenValues,
+                    mcpUrl,
+                    apiUrl: prodApiUrl,
+                    purpose: 'kody dev',
+                    ...(org ? { org } : {}),
+                })
+                : 'mock';
+            const auth = await resolveDevAuth({
+                target,
+                token,
+                apiUrl: prodApiUrl,
+                resetStorage: parsed.values['reset-storage'] === true,
+            });
+            const port = typeof parsed.values.port === 'string' ? Number(parsed.values.port) : undefined;
+            const appBasePath = typeof parsed.values['app-base-path'] === 'string'
+                ? parsed.values['app-base-path']
+                : undefined;
+            switch (subcommand) {
+                case 'serve':
+                    return await runDevServe({
+                        target,
+                        auth,
+                        port,
+                        appBasePath,
+                        allowPrivateNetwork: parsed.values['allow-private-network'] === true,
+                        io,
+                    });
+                case 'fetch': {
+                    const path = rest[0];
+                    if (!path) {
+                        throw new Error('Usage: kody dev fetch <path> [--method GET] [--body file.json]');
+                    }
+                    let body;
+                    if (bodyPath)
+                        body = await readFile(bodyPath, 'utf8');
+                    return await runDevFetch({
+                        target,
+                        auth,
+                        path,
+                        method: typeof parsed.values.method === 'string'
+                            ? parsed.values.method
+                            : undefined,
+                        body,
+                        port,
+                        appBasePath,
+                        json,
+                        io,
+                    });
+                }
+                case 'job': {
+                    const jobName = rest[0];
+                    if (!jobName)
+                        throw new Error('Usage: kody dev job <name>');
+                    return await runDevJob({ target, auth, jobName, json, io });
+                }
+                case 'webhook': {
+                    const webhookName = rest[0];
+                    if (!webhookName || !bodyPath) {
+                        throw new Error('Usage: kody dev webhook <name> --body file.json');
+                    }
+                    return await runDevWebhook({
+                        target,
+                        auth,
+                        webhookName,
+                        bodyPath,
+                        json,
+                        io,
                     });
-            write(formatToolResult(result, json));
-            return result.isError ? 1 : 0;
+                }
+                case 'emit': {
+                    const event = rest[0];
+                    if (!event || !bodyPath) {
+                        throw new Error('Usage: kody dev emit <event> --body event.json');
+                    }
+                    return await runDevEmit({
+                        target,
+                        auth,
+                        event,
+                        bodyPath,
+                        json,
+                        io,
+                    });
+                }
+                default: {
+                    const exhaustive = subcommand;
+                    throw new Error(`Unhandled kody dev subcommand: ${String(exhaustive)}`);
+                }
+            }
         }
         case 'api': {
             const operationId = parsed.positionals[0]?.trim() ?? '';
@@ -640,6 +863,20 @@ async function readStdin() {
     }
     return Buffer.concat(chunks).toString('utf8');
 }
+async function tryResolveLocalPackageInvoke(invoke) {
+    const trimmed = invoke.trim();
+    if (!trimmed || trimmed.startsWith('kody:@'))
+        return null;
+    try {
+        const { loadPackageManifest, resolveExportModulePath } = await import('./package-manifest.js');
+        const manifest = await loadPackageManifest(process.cwd());
+        const modulePath = resolveExportModulePath(manifest, trimmed);
+        return { modulePath, kodyId: manifest.kodyId };
+    }
+    catch {
+        return null;
+    }
+}
 /** True when --invoke is set alongside any code source (--code, --file, or positional). */
 export function executeSourcesConflict(input) {
     return (input.invoke !== undefined &&