@pikku/inspector 0.12.103 → 0.12.106

package/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 0.12.106
+
+### Patch Changes
+
+- fdcc821: Fabric is gone from the open toolchain. The previous names are removed with no aliases.
+
+  The CLI group is `pikku cloud …` and the export is `@pikku/cli/cloud`. The project link is the `cloud` key of `pikku.config.json` (`cloud.projectId`), the CLI keeps its local state in `~/.pikkustudio` (run `pikku cloud login` again), and the project config file is `pikkustudio.config.json`.
+
+  Every environment variable drops the `FABRIC_` prefix for `PIKKUSTUDIO_` with the same suffix: `PIKKUSTUDIO_API_URL`, `PIKKUSTUDIO_PROJECT_ID`, `PIKKUSTUDIO_TOKEN`, `PIKKUSTUDIO_OPERATOR_TOKEN`, `PIKKUSTUDIO_AUTH_PUBLIC_KEY`, `PIKKUSTUDIO_STAGE_ID` and the rest. Rename them wherever you set them.
+
+  Wire ids: the operator sign-in route is `/sign-in/cloud`, the plugin and mode literal is `'cloud'`, the Better Auth plugin is `pikkuCloud`, its session field is `pikkustudioadmin`, and the signature header is `x-cloud-sig`. The cloud API calls are `getCloudLogs`, `getCloudLogsByStageKind`, `cloudCliProjects`, `cloudCliDeployments`, `providedByCloud` and `recordCloudAnalyticsEvents`. Addon packages are `@pikkustudio/*`, scaffolded files live under `scaffold/cloud` and `__cloud_*__`, and the API hosts are the `pikkustudio.app` and `pikkustudio.dev` domains.
+
+  `pikku skills install --fabric` is `--cloud`, the install group is `cloud`, and the skills are `pikku-cloud`, `pikku-cloud-debug`, `pikku-admin-to-cloud` and `pikku-blueprint-to-cloud`.
+
+  The stale analytics forwarder copies are removed from the online-shop example and the starter template.
+
+  The sealed-box salt stays `pikkufabric/sealed-box/v1`: it is a cryptographic constant that already-sealed secrets depend on.
+
+- 33b102d: Virtual users now have one name everywhere. The id column of `virtual_user_run` and `virtual_user_schedule` is `virtual_user_id` (a migration renames it in place), the CLI group is `pikku virtual-user …`, and the declarations and imports live under `@pikku/core/virtual-user`. The previous names are removed with no aliases.
+
+  The default virtual user email domain is now `virtualuser.invalid`: apps that rely on the default domain get new accounts at the next provisioning (`pikku virtual-user sync`, deploy, or `pikku dev` start), and the old rows stay unused.
+
+  The sign-in surface carries the same name. The route is `/sign-in/virtual-user`, the environment variables are `PIKKU_ALLOW_VIRTUAL_USER_SIGN_IN` and the `PIKKU_DEV_VIRTUAL_USER_SIGN_IN` / `VITE_*` equivalents, the Better Auth plugin is `pikkuVirtualUser`, the scenario step option and wire member are `virtualUser` and `virtualUsers`, and the Better Auth user flag column is `virtual_user`. Rename the environment variables wherever you set them, and add a migration that renames the flag column on the `user` table. Nothing is aliased.
+
+  The conversation runner is now `@pikku/core/virtual-user/conversation`, replacing the old `-flow` subpath. Update the import; the old subpath is gone.
+
+- Updated dependencies [fdcc821]
+- Updated dependencies [33b102d]
+- Updated dependencies [6a25c70]
+- Updated dependencies [a084c3b]
+  - @pikku/core@0.12.142
+
+## 0.12.105
+
+### Patch Changes
+
+- b04e444: Fix CLI commands that come from an addon package. Auth and permissions set on such a command are now merged into the addon's own function instead of replacing it, and the command's input is shaped by the addon's own schema (for example a comma list becomes an array). The inspector now also resolves `...refCLI('addon:contract')`, spreads and `defineCLICommands` identifiers inside a command's `subcommands`.
+- Updated dependencies [b04e444]
+- Updated dependencies [d3d8a98]
+- Updated dependencies [658da50]
+  - @pikku/core@0.12.141
+
+## 0.12.104
+
+### Patch Changes
+
+- 5464b86: Add the `pikku verify` command over `@pikku/code-edit/verify`: codegen, the backend and frontend type-checks and static correctness checks as structured findings with fix hints. The inspector warns about single-step workflows (PKU644) and PKU111 now names the file and line.
+- Updated dependencies [f396538]
+  - @pikku/core@0.12.140
+
 ## 0.12.103
 
 ### Patch Changes

package/dist/add/add-cli.js

@@ -325,15 +325,23 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                 }
                 break;
             case 'subcommands': {
-                let subcommandsNode = prop.initializer;
-                if (ts.isIdentifier(prop.initializer)) {
-                    subcommandsNode = resolveIdentifier(prop.initializer, typeChecker, [
-                        'defineCLICommands',
-                    ]);
-                }
-                if (subcommandsNode && ts.isObjectLiteralExpression(subcommandsNode)) {
-                    meta.subcommands = {};
-                    for (const subProp of subcommandsNode.properties) {
+                const subcommands = {};
+                const collect = (node) => {
+                    const refContract = resolveRefContract(node, 'refCLI', inspectorState.exportedContracts.addonCli);
+                    if (refContract) {
+                        Object.assign(subcommands, refContract.contract);
+                        return;
+                    }
+                    const target = ts.isIdentifier(node)
+                        ? resolveIdentifier(node, typeChecker, ['defineCLICommands'])
+                        : node;
+                    if (!target || !ts.isObjectLiteralExpression(target))
+                        return;
+                    for (const subProp of target.properties) {
+                        if (ts.isSpreadAssignment(subProp)) {
+                            collect(subProp.expression);
+                            continue;
+                        }
                         if (!ts.isPropertyAssignment(subProp))
                             continue;
                         const subName = getPropertyName(subProp);
@@ -341,10 +349,12 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                             continue;
                         const subCommand = processCommand(logger, inspectorState, options, subName, subProp.initializer, sourceFile, typeChecker, programName, fullPath, programTags);
                         if (subCommand) {
-                            meta.subcommands[subName] = subCommand;
+                            subcommands[subName] = subCommand;
                         }
                     }
-                }
+                };
+                collect(prop.initializer);
+                meta.subcommands = subcommands;
                 break;
             }
             case 'isDefault':

package/dist/add/add-functions.js

@@ -21,7 +21,7 @@ const SCENARIO_SURFACE_KEYS = [
  * copied into an addon package by a consumer, a called identifier cannot.
  */
 const SCENARIO_STEP_KINDS = new Map([
-    ['pikkuScenarioStep', 'persona'],
+    ['pikkuScenarioStep', 'virtualUser'],
     ['pikkuPlatformScenarioStep', 'platform'],
     ['pikkuAddonScenarioStep', 'addon'],
 ]);
@@ -424,7 +424,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let workflowRetries;
     let workflowTimeout;
     let scenarioStepSurfaces;
-    let scenarioStepRequiresActor;
+    let scenarioStepRequiresVirtualUser;
     let scenarioStepAddon;
     let scenarioStepTemplate;
     let scopes;
@@ -560,9 +560,9 @@ export const addFunctions = (logger, node, checker, state, options) => {
                 ? declaredSurfaces
                 : undefined;
             // A browser binding cannot be provisioned without a window to open, so it
-            // requires an actor whether or not the step said so.
-            scenarioStepRequiresActor =
-                getPropertyValue(firstArg, 'actor') === true ||
+            // requires a virtual user whether or not the step said so.
+            scenarioStepRequiresVirtualUser =
+                getPropertyValue(firstArg, 'virtualUser') === true ||
                     declaredSurfaces.includes('browser')
                     ? true
                     : undefined;
@@ -1083,10 +1083,10 @@ export const addFunctions = (logger, node, checker, state, options) => {
         workflowTimeout: workflowTimeout ?? undefined,
         compensate: compensateInitializer ? true : undefined,
         scenarioStepSurfaces,
-        scenarioStepRequiresActor,
-        // `persona` is the default reading of an unmarked step, so it is left off
+        scenarioStepRequiresVirtualUser,
+        // `virtualUser` is the default reading of an unmarked step, so it is left off
         // rather than written into every step meta a project already has.
-        scenarioStepKind: scenarioStepKind && scenarioStepKind !== 'persona'
+        scenarioStepKind: scenarioStepKind && scenarioStepKind !== 'virtualUser'
             ? scenarioStepKind
             : undefined,
         scenarioStepAddon,

package/dist/add/add-virtual-users.d.ts

@@ -0,0 +1,13 @@
+import type { AddWiring } from '../types.js';
+/**
+ * Inspector for `defineVirtualUsers()` calls.
+ *
+ * A virtual user is entirely declaration — a person, their roles, what they want —
+ * so there is no code body and nothing to resolve at runtime. What is read here
+ * is the whole thing, and it is generated straight to `virtual-users.gen.json` for
+ * the CLI and the console to read without loading the app.
+ *
+ * `name` is the one field that cannot be defaulted. A virtual user without one is
+ * not a person, and the console has nothing to show.
+ */
+export declare const addVirtualUsers: AddWiring;

package/dist/add/{add-personas.js → add-virtual-users.js}

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { DISPOSITIONS } from '@pikku/core/virtual-user';
-import { isRunnablePersona } from '@pikku/core/persona';
+import { isRunnableVirtualUser } from '@pikku/core/virtual-user';
 import { ErrorCode } from '../error-codes.js';
 import { claimSingleDeclaration } from '../utils/single-declaration.js';
 import { booleanProperty, getProperty, numberProperty, stringArrayProperty, stringProperty, unwrapAs, } from '../utils/literal-properties.js';
@@ -15,7 +15,7 @@ const RATES = [
  *
  * The ranges are checked here rather than at run time because these are the
  * kind of typo that does not throw: `repeatRate: 18` meaning 18% would silently
- * double every call the persona makes, and you would read the run as a product
+ * double every call the virtual user makes, and you would read the run as a product
  * bug.
  */
 const tuningProperty = (config, onError) => {
@@ -72,7 +72,7 @@ const accountProperty = (value) => {
     const provider = stringProperty(value, 'provider');
     return provider === undefined ? {} : { provider };
 };
-const linkedAccountsProperty = (config, personaId, logger) => {
+const linkedAccountsProperty = (config, virtualUserId, logger) => {
     const value = getProperty(config, 'linkedAccounts');
     if (!value || !ts.isObjectLiteralExpression(value)) {
         return undefined;
@@ -83,12 +83,12 @@ const linkedAccountsProperty = (config, personaId, logger) => {
             continue;
         }
         if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)) {
-            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, `Persona '${personaId}' has a linked account whose key is not a literal.`);
+            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, `VirtualUser '${virtualUserId}' has a linked account whose key is not a literal.`);
             continue;
         }
         const account = accountProperty(prop.initializer);
         if (!account) {
-            logger.critical(ErrorCode.INVALID_VALUE, `Persona '${personaId}' linked account '${prop.name.text}' must be an object literal.`);
+            logger.critical(ErrorCode.INVALID_VALUE, `VirtualUser '${virtualUserId}' linked account '${prop.name.text}' must be an object literal.`);
             continue;
         }
         accounts[prop.name.text] = account;
@@ -96,22 +96,22 @@ const linkedAccountsProperty = (config, personaId, logger) => {
     return Object.keys(accounts).length ? accounts : undefined;
 };
 /**
- * Inspector for `definePersonas()` calls.
+ * Inspector for `defineVirtualUsers()` calls.
  *
- * A persona is entirely declaration — a person, their roles, what they want —
+ * A virtual user is entirely declaration — a person, their roles, what they want —
  * so there is no code body and nothing to resolve at runtime. What is read here
- * is the whole thing, and it is generated straight to `personas.gen.json` for
+ * is the whole thing, and it is generated straight to `virtual-users.gen.json` for
  * the CLI and the console to read without loading the app.
  *
- * `name` is the one field that cannot be defaulted. A persona without one is
+ * `name` is the one field that cannot be defaulted. A virtual user without one is
  * not a person, and the console has nothing to show.
  */
-export const addPersonas = (logger, node, _checker, state) => {
+export const addVirtualUsers = (logger, node, _checker, state) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
     const expression = node.expression;
-    if (!ts.isIdentifier(expression) || expression.text !== 'definePersonas') {
+    if (!ts.isIdentifier(expression) || expression.text !== 'defineVirtualUsers') {
         return;
     }
     const firstArg = node.arguments[0];
@@ -120,11 +120,11 @@ export const addPersonas = (logger, node, _checker, state) => {
     }
     const unwrapped = unwrapAs(firstArg);
     if (!ts.isObjectLiteralExpression(unwrapped)) {
-        logger.critical(ErrorCode.INVALID_VALUE, 'definePersonas() needs an inline object — personas are read statically, never evaluated.');
+        logger.critical(ErrorCode.INVALID_VALUE, 'defineVirtualUsers() needs an inline object — virtual users are read statically, never evaluated.');
         return;
     }
     const sourceFile = node.getSourceFile().fileName;
-    if (!claimSingleDeclaration(logger, state.personas.files, ErrorCode.DUPLICATE_PERSONAS_DEFINITION, 'definePersonas', sourceFile)) {
+    if (!claimSingleDeclaration(logger, state.virtualUsers.files, ErrorCode.DUPLICATE_VIRTUAL_USERS_DEFINITION, 'defineVirtualUsers', sourceFile)) {
         return;
     }
     const known = Object.keys(DISPOSITIONS);
@@ -133,46 +133,46 @@ export const addPersonas = (logger, node, _checker, state) => {
             continue;
         }
         if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name)) {
-            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, 'A persona is declared with a key that is not a literal.');
+            logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, 'A virtual user is declared with a key that is not a literal.');
             continue;
         }
         const id = prop.name.text;
         if (!ts.isObjectLiteralExpression(prop.initializer)) {
-            logger.critical(ErrorCode.INVALID_VALUE, `Persona '${id}' must be an object literal.`);
+            logger.critical(ErrorCode.INVALID_VALUE, `VirtualUser '${id}' must be an object literal.`);
             continue;
         }
         const config = prop.initializer;
         const name = stringProperty(config, 'name');
         if (!name) {
-            logger.critical(ErrorCode.INVALID_VALUE, `Persona '${id}' needs a literal 'name' — a persona is a person, and the console has nothing to show without one.`);
+            logger.critical(ErrorCode.INVALID_VALUE, `VirtualUser '${id}' needs a literal 'name' — a virtual user is a person, and the console has nothing to show without one.`);
             continue;
         }
-        // The generated `definePersonas` types this as a union, so a bad value only
+        // The generated `defineVirtualUsers` types this as a union, so a bad value only
         // reaches here in source that does not compile. Caught anyway: a
         // disposition is the entire behaviour, and defaulting a typo to `realistic`
         // would run a different person than the one that was written.
         const disposition = stringProperty(config, 'disposition');
         if (disposition !== undefined && !known.includes(disposition)) {
-            logger.critical(ErrorCode.INVALID_VALUE, `Persona '${id}' has an unknown disposition '${disposition}'. One of: ${known.join(', ')}`);
+            logger.critical(ErrorCode.INVALID_VALUE, `VirtualUser '${id}' has an unknown disposition '${disposition}'. One of: ${known.join(', ')}`);
             continue;
         }
         let tuningFailed = false;
         const tuning = tuningProperty(config, (message) => {
             tuningFailed = true;
-            logger.critical(ErrorCode.INVALID_VALUE, `Persona '${id}': ${message}`);
+            logger.critical(ErrorCode.INVALID_VALUE, `VirtualUser '${id}': ${message}`);
         });
         if (tuningFailed) {
             continue;
         }
         const account = accountProperty(getProperty(config, 'account'));
         const declaredRunnable = booleanProperty(config, 'runnable');
-        const persona = {
+        const virtualUser = {
             id,
             name,
             roles: stringArrayProperty(config, 'roles') ?? [],
             goals: stringArrayProperty(config, 'goals') ?? [],
             tags: stringArrayProperty(config, 'tags') ?? [],
-            runnable: isRunnablePersona({
+            runnable: isRunnableVirtualUser({
                 ...(declaredRunnable !== undefined
                     ? { runnable: declaredRunnable }
                     : {}),
@@ -182,38 +182,38 @@ export const addPersonas = (logger, node, _checker, state) => {
         };
         const jobTitle = stringProperty(config, 'jobTitle');
         if (jobTitle !== undefined)
-            persona.jobTitle = jobTitle;
+            virtualUser.jobTitle = jobTitle;
         const description = stringProperty(config, 'description');
         if (description !== undefined)
-            persona.description = description;
+            virtualUser.description = description;
         const avatarUrl = stringProperty(config, 'avatarUrl');
         if (avatarUrl !== undefined)
-            persona.avatarUrl = avatarUrl;
+            virtualUser.avatarUrl = avatarUrl;
         const personality = stringProperty(config, 'personality');
         if (personality !== undefined)
-            persona.personality = personality;
+            virtualUser.personality = personality;
         const app = stringProperty(config, 'app');
         if (app !== undefined)
-            persona.app = app;
+            virtualUser.app = app;
         if (disposition !== undefined) {
-            persona.disposition = disposition;
+            virtualUser.disposition = disposition;
         }
         if (tuning !== undefined)
-            persona.tuning = tuning;
+            virtualUser.tuning = tuning;
         const fixtures = stringArrayProperty(config, 'fixtures');
         if (fixtures !== undefined)
-            persona.fixtures = fixtures;
+            virtualUser.fixtures = fixtures;
         // Left absent rather than resolved here: "everywhere but production" is a
         // fact about the config, and the inspector has no business baking today's
         // environment list into a meta file that outlives it.
         const environments = stringArrayProperty(config, 'environments');
         if (environments !== undefined)
-            persona.environments = environments;
+            virtualUser.environments = environments;
         if (account !== undefined)
-            persona.account = account;
+            virtualUser.account = account;
         const linkedAccounts = linkedAccountsProperty(config, id, logger);
         if (linkedAccounts !== undefined)
-            persona.linkedAccounts = linkedAccounts;
-        state.personas.definitions.push(persona);
+            virtualUser.linkedAccounts = linkedAccounts;
+        state.virtualUsers.definitions.push(virtualUser);
     }
 };

package/dist/add/add-workflow.js

@@ -1,11 +1,12 @@
 import * as ts from 'typescript';
+import { relative } from 'node:path';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { ErrorCode } from '../error-codes.js';
 import { extractStringLiteral, isStringLike, isFunctionLike, extractDescription, extractDuration, } from '../utils/extract-node-value.js';
 import { getCommonWireMetaData, getPropertyValue, } from '../utils/get-property-value.js';
 import { extractDSLWorkflow } from '../utils/workflow/dsl/extract-dsl-workflow.js';
-import { getSourceText, extractActorFromOptions, } from '../utils/workflow/dsl/patterns.js';
+import { getSourceText, extractVirtualUserFromOptions, } from '../utils/workflow/dsl/patterns.js';
 /**
  * Extract a workflow step's display name without letting a non-static name
  * (e.g. a function call) abort the scan. The step name is cosmetic, so a
@@ -141,7 +142,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                             type: 'rpc',
                             stepName,
                             rpcName,
-                            actor: extractActorFromOptions(optionsArg),
+                            virtualUser: extractVirtualUserFromOptions(optionsArg),
                         });
                         state.rpc.invokedFunctions.add(rpcName);
                     }
@@ -164,7 +165,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                             stepName,
                             rpcName,
                             expectEventually: true,
-                            actor: extractActorFromOptions(args.length >= 5 ? args[4] : undefined),
+                            virtualUser: extractVirtualUserFromOptions(args.length >= 5 ? args[4] : undefined),
                         });
                         state.rpc.invokedFunctions.add(rpcName);
                     }
@@ -229,7 +230,7 @@ export const addWorkflow = (logger, node, checker, state, options) => {
         wrapperType = 'complex';
     }
     else if (expression.text === 'pikkuScenario') {
-        // A scenario is a complex workflow whose steps run as actors over the
+        // A scenario is a complex workflow whose steps run as virtual users over the
         // real transport — same extraction rules as complex, distinct meta.
         wrapperType = 'scenario';
     }
@@ -243,7 +244,10 @@ export const addWorkflow = (logger, node, checker, state, options) => {
     const { pikkuFuncId, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
     const workflowName = exportedName || name;
     if (!workflowName) {
-        logger.critical(ErrorCode.MISSING_NAME, `Could not determine workflow name from export.`);
+        const sourceFile = node.getSourceFile();
+        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        logger.critical(ErrorCode.MISSING_NAME, `Could not determine workflow name from export at ${relative(state.rootDir, sourceFile.fileName)}:${line + 1}. ` +
+            `Assign the \`${expression.text}(...)\` call to an exported const; that name is how it is registered.`);
         return;
     }
     // Extract the function node (either direct function or from config.func)
@@ -358,11 +362,11 @@ export const addWorkflow = (logger, node, checker, state, options) => {
         const sink = steps.length > 0 ? [] : steps;
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, sink);
     }
-    // Actor names the flow's steps run as (scenarios) — powers the console
-    // personas view and the Scenario graph badges.
-    const actorNames = [
+    // Virtual user names the flow's steps run as (scenarios) — powers the console
+    // virtual users view and the Scenario graph badges.
+    const virtualUserNames = [
         ...new Set(steps
-            .map((s) => ('actor' in s ? s.actor : undefined))
+            .map((s) => ('virtualUser' in s ? s.virtualUser : undefined))
             .filter((a) => typeof a === 'string')),
     ];
     state.workflows.meta[workflowName] = {
@@ -380,7 +384,7 @@ export const addWorkflow = (logger, node, checker, state, options) => {
         skip,
         scenario: wrapperType === 'scenario' ? true : undefined,
         asserts,
-        actors: actorNames.length > 0 ? actorNames : undefined,
+        virtualUsers: virtualUserNames.length > 0 ? virtualUserNames : undefined,
     };
     // The scenario "logger/config only" rule (PKU673) and the implicit
     // workflow platform-service injection both used to live here, reading

package/dist/error-codes.d.ts

@@ -20,16 +20,17 @@ export declare enum ErrorCode {
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
     SCENARIO_HAS_SERVICES = "PKU673",
     EXPECT_EVENTUALLY_SCENARIO_ONLY = "PKU675",
-    SCENARIO_STEP_NEEDS_ACTOR = "PKU677",
+    SCENARIO_STEP_NEEDS_VIRTUAL_USER = "PKU677",
     SCENARIO_STEP_TARGET_NOT_STATIC = "PKU678",
     SCENARIO_NOT_EXTRACTABLE = "PKU679",
     SCENARIO_HAS_NO_ASSERTION = "PKU680",
-    SCENARIO_STEP_PROSE_NAMES_ACTOR = "PKU681",
+    SCENARIO_STEP_PROSE_NAMES_VIRTUAL_USER = "PKU681",
     SCENARIO_HAS_NO_FEATURE = "PKU682",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
     INVALID_DSL_WORKFLOW = "PKU641",
     WORKFLOW_GRAPH_ADDON_NOT_WIRED = "PKU642",
     COMPLEX_WORKFLOW_NOT_ALLOWED = "PKU643",
+    SINGLE_STEP_WORKFLOW = "PKU644",
     REMOTE_ADDON_NOT_DEV_DEPENDENCY = "PKU338",
     REMOTE_ADDON_AUTH_UNRESOLVED = "PKU339",
     ADDON_NOT_INSTALLED = "PKU340",
@@ -53,7 +54,7 @@ export declare enum ErrorCode {
     FUNCTION_METADATA_NOT_FOUND = "PKU559",
     DUPLICATE_AUTH_DEFINITION = "PKU581",
     AUTH_NOT_EXPORTED = "PKU582",
-    DUPLICATE_PERSONAS_DEFINITION = "PKU585",
+    DUPLICATE_VIRTUAL_USERS_DEFINITION = "PKU585",
     ROUTE_PARAM_MISMATCH = "PKU571",
     ROUTE_QUERY_MISMATCH = "PKU572",
     AUTH_DISABLED_REQUIRES_SESSIONLESS = "PKU573",

package/dist/error-codes.js

@@ -22,16 +22,17 @@ export var ErrorCode;
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
     ErrorCode["SCENARIO_HAS_SERVICES"] = "PKU673";
     ErrorCode["EXPECT_EVENTUALLY_SCENARIO_ONLY"] = "PKU675";
-    ErrorCode["SCENARIO_STEP_NEEDS_ACTOR"] = "PKU677";
+    ErrorCode["SCENARIO_STEP_NEEDS_VIRTUAL_USER"] = "PKU677";
     ErrorCode["SCENARIO_STEP_TARGET_NOT_STATIC"] = "PKU678";
     ErrorCode["SCENARIO_NOT_EXTRACTABLE"] = "PKU679";
     ErrorCode["SCENARIO_HAS_NO_ASSERTION"] = "PKU680";
-    ErrorCode["SCENARIO_STEP_PROSE_NAMES_ACTOR"] = "PKU681";
+    ErrorCode["SCENARIO_STEP_PROSE_NAMES_VIRTUAL_USER"] = "PKU681";
     ErrorCode["SCENARIO_HAS_NO_FEATURE"] = "PKU682";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
     ErrorCode["INVALID_DSL_WORKFLOW"] = "PKU641";
     ErrorCode["WORKFLOW_GRAPH_ADDON_NOT_WIRED"] = "PKU642";
     ErrorCode["COMPLEX_WORKFLOW_NOT_ALLOWED"] = "PKU643";
+    ErrorCode["SINGLE_STEP_WORKFLOW"] = "PKU644";
     // Remote addon (wireRemoteAddon) validation
     ErrorCode["REMOTE_ADDON_NOT_DEV_DEPENDENCY"] = "PKU338";
     ErrorCode["REMOTE_ADDON_AUTH_UNRESOLVED"] = "PKU339";
@@ -65,7 +66,7 @@ export var ErrorCode;
     // scopes and roles held this rule until the generated `admin` tree made it
     // unsatisfiable, and get it back once `admin` is a default scope nobody
     // declares. Do not reuse those two numbers for anything else.
-    ErrorCode["DUPLICATE_PERSONAS_DEFINITION"] = "PKU585";
+    ErrorCode["DUPLICATE_VIRTUAL_USERS_DEFINITION"] = "PKU585";
     // HTTP Route errors
     ErrorCode["ROUTE_PARAM_MISMATCH"] = "PKU571";
     ErrorCode["ROUTE_QUERY_MISMATCH"] = "PKU572";

package/dist/inspector.js

@@ -9,9 +9,10 @@ import { findCommonAncestor } from './utils/find-root-dir.js';
 import { createSourceFileCacheHost } from './source-file-cache.js';
 import { createNestedProjectFilter } from './utils/nested-project-filter.js';
 import { toProgramPath } from './utils/program-path.js';
-import { aggregateRequiredServices, stampAuthHandlerServices, validateAgentModels, validateAgentToolReferences, validateAgentScorerReferences, validateSecretOverrides, validateVariableOverrides, validateCredentialOverrides, validateAddonUses, validateAddonContentGrants, validateRemoteAddonDependencies, validateRemoteAddonAuth, validateScopeReferences, validateSystemRoleScopes, validatePersonaRoles, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, validateNoSecretAliasServices, registerDerivedOAuth2AppSecrets, validateSecretUsage, computeDiagnostics, validateSchemaReferences, validateSchemaWiringSeparation, validateScenarioServices, validateScenarioSteps, validateScenarioFeatures, validateWorkflowGraphAddons, } from './utils/post-process.js';
+import { aggregateRequiredServices, stampAuthHandlerServices, validateAgentModels, validateAgentToolReferences, validateAgentScorerReferences, validateSecretOverrides, validateVariableOverrides, validateCredentialOverrides, validateAddonUses, validateAddonContentGrants, validateRemoteAddonDependencies, validateRemoteAddonAuth, validateScopeReferences, validateSystemRoleScopes, validateVirtualUserRoles, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, validateNoSecretAliasServices, registerDerivedOAuth2AppSecrets, validateSecretUsage, computeDiagnostics, validateSchemaReferences, validateSchemaWiringSeparation, validateScenarioServices, validateScenarioSteps, validateScenarioFeatures, validateWorkflowGraphAddons, } from './utils/post-process.js';
 import { validateExposedFunctionsGated } from './utils/validate-exposed-functions-gated.js';
 import { validateTagsResolveToMiddleware } from './utils/validate-tags-resolve-to-middleware.js';
+import { validateSingleStepWorkflows } from './utils/validate-single-step-workflows.js';
 import { annotateHttpRouteAuth } from './utils/annotate-http-route-auth.js';
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
 import { pikkuState } from '@pikku/core/state';
@@ -169,7 +170,7 @@ export function getInitialInspectorState(rootDir) {
             definitions: [],
             files: new Set(),
         },
-        personas: {
+        virtualUsers: {
             definitions: [],
             files: new Set(),
         },
@@ -408,6 +409,7 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         computeDiagnostics(state);
         validateSchemaWiringSeparation(logger, state);
         validateWorkflowGraphAddons(logger, state);
+        validateSingleStepWorkflows(logger, state);
         validateScenarioServices(logger, state);
         validateScenarioSteps(logger, state);
         validateScenarioFeatures(logger, state);
@@ -434,7 +436,7 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         applyDeclaredScopes(state);
         validateScopeReferences(logger, state);
         validateSystemRoleScopes(logger, state);
-        validatePersonaRoles(logger, state);
+        validateVirtualUserRoles(logger, state);
         logger.endValidationPass?.();
     }
     const cpu = process.cpuUsage(cpuStart);

package/dist/types.d.ts

@@ -19,7 +19,7 @@ import type { CredentialDefinitions } from '@pikku/core/credential';
 import type { ScopeDefinitions } from '@pikku/core/scope';
 import type { SystemRoleDefinitions } from '@pikku/core/role';
 import type { FeatureFlagDefinitions } from '@pikku/core/flag';
-import type { PersonaDefinitions } from '@pikku/core/persona';
+import type { VirtualUserDefinitions } from '@pikku/core/virtual-user';
 import type { VariableDefinitions } from '@pikku/core/variable';
 import type { TypesMap } from './types-map.js';
 import type { FunctionsMeta } from '@pikku/core/services';
@@ -784,8 +784,8 @@ export interface InspectorState {
         definitions: FeatureFlagDefinitions;
         files: Set<string>;
     };
-    personas: {
-        definitions: PersonaDefinitions;
+    virtualUsers: {
+        definitions: VirtualUserDefinitions;
         files: Set<string>;
     };
     variables: {

package/dist/utils/extract-function-name.js

@@ -30,7 +30,7 @@ export function funcIdToTypeName(id) {
 }
 /**
  * The step wrappers, whichever kind of subject acts in them. A scenario calls a
- * platform or addon step by name exactly as it calls a persona one.
+ * platform or addon step by name exactly as it calls a virtual user one.
  */
 const SCENARIO_STEP_WRAPPERS = new Set([
     'pikkuScenarioStep',

package/dist/utils/get-property-value.js

@@ -102,7 +102,7 @@ export const assertStringLiteralProperty = (obj, propertyName, wiringType, logge
  * that anything written as an expression comes through raw: a `description`
  * split across lines as `'Fetch the thing ' + 'from upstream'` reaches
  * `infra.json` with the quotes and the `+` still in it, and is rendered that
- * way in the fabric console.
+ * way in the cloud console.
  *
  * Deliberately checker-free, unlike `extractStringLiteral`. Every value this
  * resolves is a literal in the same expression, so no symbol resolution is

package/dist/utils/load-addon-functions-meta.js

@@ -45,6 +45,7 @@ const applyPackageToCLICommands = (commands, packageName, namespace) => {
             }
             if (namespace &&
                 typeof command.pikkuFuncId === 'string' &&
+                command.pikkuFuncId !== '' &&
                 !command.pikkuFuncId.includes(':')) {
                 command.pikkuFuncId = `${namespace}:${command.pikkuFuncId}`;
             }