@pikku/inspector 0.12.102 → 0.12.106

package/CHANGELOG.md

@@ -1,3 +1,64 @@
+## 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
+
+- 53ac40d: An addon can ship screens: `wireAddon({ ui: true })` mounts what the package declares with `defineScreens`, the inspector reads them, `pikku all` emits the screens manifest and the installed-addons registry, and `x-pikku-addon` narrows a session to the addon's role. `pikku new addon --ui` scaffolds one; its tables must be prefixed `<name>_`.
+- Updated dependencies [a196a21]
+- Updated dependencies [53ac40d]
+- Updated dependencies [443fd40]
+- Updated dependencies [56c8047]
+  - @pikku/core@0.12.139
+
 ## 0.12.102
 
 ### 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-define-screens.d.ts

@@ -0,0 +1,8 @@
+import * as ts from 'typescript';
+import type { InspectorState, InspectorLogger } from '../types.js';
+/**
+ * Detect `defineScreens({ title, icon, screens })` and record the manifest.
+ * A screen with a field that is not a literal is reported and left out: a
+ * navigation entry the host cannot read would otherwise vanish with no sign.
+ */
+export declare function addDefineScreens(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-define-screens.js

@@ -0,0 +1,140 @@
+import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+const propName = (prop) => {
+    if (!ts.isPropertyAssignment(prop))
+        return undefined;
+    return ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
+        ? prop.name.text
+        : undefined;
+};
+const stringArray = (node) => {
+    if (!ts.isArrayLiteralExpression(node))
+        return undefined;
+    const values = [];
+    for (const element of node.elements) {
+        if (!ts.isStringLiteral(element))
+            return undefined;
+        values.push(element.text);
+    }
+    return values;
+};
+/**
+ * The module specifier of `() => import('./screens/x')`. Anything else cannot
+ * be handed to the host's bundler as a lazy import, so it is not read.
+ */
+const lazyImportSpecifier = (node) => {
+    if (!ts.isArrowFunction(node))
+        return undefined;
+    const body = node.body;
+    if (!ts.isCallExpression(body) ||
+        body.expression.kind !== ts.SyntaxKind.ImportKeyword)
+        return undefined;
+    const [specifier] = body.arguments;
+    return specifier && ts.isStringLiteral(specifier) ? specifier.text : undefined;
+};
+/**
+ * Detect `defineScreens({ title, icon, screens })` and record the manifest.
+ * A screen with a field that is not a literal is reported and left out: a
+ * navigation entry the host cannot read would otherwise vanish with no sign.
+ */
+export function addDefineScreens(node, state, logger) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'defineScreens')
+        return;
+    const [firstArg] = args;
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    const fail = (message) => logger.critical(ErrorCode.ADDON_SCREENS_NOT_STATIC, message);
+    let title;
+    let icon;
+    const screens = [];
+    for (const prop of firstArg.properties) {
+        const key = propName(prop);
+        if (!key || !ts.isPropertyAssignment(prop))
+            continue;
+        if (key === 'title' && ts.isStringLiteral(prop.initializer)) {
+            title = prop.initializer.text;
+        }
+        else if (key === 'icon' && ts.isStringLiteral(prop.initializer)) {
+            icon = prop.initializer.text;
+        }
+        else if (key === 'screens') {
+            if (!ts.isArrayLiteralExpression(prop.initializer)) {
+                fail(`defineScreens's screens must be an array literal, got: ${prop.initializer.getText()}`);
+                continue;
+            }
+            for (const element of prop.initializer.elements) {
+                if (!ts.isObjectLiteralExpression(element)) {
+                    fail(`A defineScreens screen must be an object literal, got: ${element.getText()}`);
+                    continue;
+                }
+                let path;
+                let screenTitle;
+                let nav;
+                let scopes;
+                let component;
+                let app;
+                for (const field of element.properties) {
+                    const fieldKey = propName(field);
+                    if (!fieldKey || !ts.isPropertyAssignment(field))
+                        continue;
+                    const value = field.initializer;
+                    if (fieldKey === 'path' && ts.isStringLiteral(value)) {
+                        path = value.text;
+                    }
+                    else if (fieldKey === 'title' && ts.isStringLiteral(value)) {
+                        screenTitle = value.text;
+                    }
+                    else if (fieldKey === 'nav' &&
+                        (value.kind === ts.SyntaxKind.TrueKeyword ||
+                            value.kind === ts.SyntaxKind.FalseKeyword)) {
+                        nav = value.kind === ts.SyntaxKind.TrueKeyword;
+                    }
+                    else if (fieldKey === 'scopes') {
+                        scopes = stringArray(value);
+                        if (!scopes) {
+                            fail(`A screen's scopes must be an array of string literals, got: ${value.getText()}`);
+                        }
+                    }
+                    else if (fieldKey === 'component') {
+                        component = lazyImportSpecifier(value);
+                        if (!component) {
+                            fail(`A screen's component must be () => import('<literal>'), got: ${value.getText()}`);
+                        }
+                    }
+                    else if (fieldKey === 'app' && ts.isStringLiteral(value)) {
+                        app = value.text;
+                    }
+                }
+                if (!path || !screenTitle || (!component && !app)) {
+                    fail(`A defineScreens screen needs a literal path and title, and either a lazy component or an app: ${element.getText()}`);
+                    continue;
+                }
+                if (component && app) {
+                    fail(`Screen '${path}' sets both component and app; a screen is one or the other`);
+                    continue;
+                }
+                screens.push({
+                    path,
+                    title: screenTitle,
+                    ...(nav !== undefined ? { nav } : {}),
+                    ...(scopes ? { scopes } : {}),
+                    ...(component ? { component } : { app: app }),
+                });
+            }
+        }
+    }
+    if (!title) {
+        fail(`defineScreens needs a literal title`);
+        return;
+    }
+    logger.debug(`• Found defineScreens: ${title} (${screens.length} screens)`);
+    state.screensManifest = {
+        title,
+        ...(icon ? { icon } : {}),
+        file: node.getSourceFile().fileName,
+        screens,
+    };
+}

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-wire-addon.js

@@ -87,7 +87,8 @@ export function addWireAddon(node, state, logger) {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireAddon')
+    if (!ts.isIdentifier(expression) ||
+        expression.text !== 'wireAddon')
         return;
     const [firstArg] = args;
     if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
@@ -99,8 +100,10 @@ export function addWireAddon(node, state, logger) {
     let expose;
     let mcpEndpoint;
     let auth;
+    let ui;
     let tags;
     let scopes;
+    let uses;
     let secretOverrides;
     let variableOverrides;
     let credentialOverrides;
@@ -108,6 +111,9 @@ export function addWireAddon(node, state, logger) {
     let credentialGrants;
     let globalSecrets;
     let globalCredentials;
+    let contentBucket;
+    let contentGrants;
+    let globalContent;
     for (const prop of firstArg.properties) {
         if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
             continue;
@@ -154,12 +160,25 @@ export function addWireAddon(node, state, logger) {
                 prop.initializer.kind === ts.SyntaxKind.FalseKeyword)) {
             auth = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
         }
+        else if (key === 'ui' &&
+            (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts.SyntaxKind.FalseKeyword)) {
+            ui = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+        }
         else if (key === 'tags') {
             tags = parseStringArray(prop.initializer);
         }
         else if (key === 'scopes') {
             scopes = parseStringArray(prop.initializer);
         }
+        else if (key === 'uses') {
+            if (ts.isObjectLiteralExpression(prop.initializer)) {
+                uses = parseStringRecord(prop.initializer);
+            }
+            else {
+                logger.critical(ErrorCode.ADDON_EXPOSE_NOT_STATIC, `wireAddon's uses must be an object literal, got: ${prop.initializer.getText()}`);
+            }
+        }
         else if (key === 'secretOverrides' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
             secretOverrides = parseStringRecord(prop.initializer);
@@ -190,12 +209,26 @@ export function addWireAddon(node, state, logger) {
                 ? prop.initializer.text
                 : prop.initializer.getText();
         }
+        else if (key === 'contentBucket' &&
+            ts.isStringLiteral(prop.initializer)) {
+            contentBucket = prop.initializer.text;
+        }
+        else if (key === 'contentGrants' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            contentGrants = parseStringRecord(prop.initializer);
+        }
+        else if (key === 'globalContent') {
+            globalContent = ts.isStringLiteral(prop.initializer)
+                ? prop.initializer.text
+                : prop.initializer.getText();
+        }
     }
     if (!name || !pkg)
         return;
-    logger.debug(`• Found wireAddon: ${name} → ${pkg}`);
+    logger.debug(`• Found ${expression.text}: ${name} → ${pkg}`);
     state.rpc.wireAddonDeclarations.set(name, {
         package: pkg,
+        ...(ui ? { ui } : {}),
         file: node.getSourceFile().fileName,
         rpcEndpoint,
         mcp,
@@ -204,6 +237,7 @@ export function addWireAddon(node, state, logger) {
         auth,
         tags,
         scopes,
+        uses,
         secretOverrides,
         variableOverrides,
         credentialOverrides,
@@ -211,6 +245,9 @@ export function addWireAddon(node, state, logger) {
         credentialGrants,
         globalSecrets,
         globalCredentials,
+        contentBucket,
+        contentGrants,
+        globalContent,
     });
     state.rpc.usedAddons.add(name);
     state.rpc.wireAddonFiles.add(node.getSourceFile().fileName);