windows-development-sandbox 1.27.1 → 1.27.3

package/dist/app/context.d.ts

@@ -4,5 +4,10 @@ import { type OperationIO } from './kernel/index.js';
 export type AppContext = Context;
 /** Attaches a run function to a definition: `implement(def, async (ctx, input, io) => output)`. */
 export declare const implement: <D extends import("./kernel/define.js").AnyDefinition>(def: D, run: (ctx: Context, input: import("zod").infer<D["input"]>, io: OperationIO) => import("zod").infer<D["output"]> | Promise<import("zod").infer<D["output"]>>) => import("./kernel/define.js").Implementation<D, Context>;
+/**
+ * Reads the settings again after an operation, so a long-lived context (the menu, the web server) shows what it saved.
+ * A file that cannot be read keeps the settings the context had: the settings page reports the problem.
+ */
+export declare function reloadSettings(ctx: AppContext): void;
 /** Another user's sandbox asks for their name to be typed: through `io`, so every surface can ask it. */
 export declare function typedConfirm(io: OperationIO): TypedConfirm;

package/dist/app/context.js

@@ -1,6 +1,19 @@
+import { loadConfig } from '../core/config/index.js';
 import { implementer } from './kernel/index.js';
 /** Attaches a run function to a definition: `implement(def, async (ctx, input, io) => output)`. */
 export const implement = implementer();
+/**
+ * Reads the settings again after an operation, so a long-lived context (the menu, the web server) shows what it saved.
+ * A file that cannot be read keeps the settings the context had: the settings page reports the problem.
+ */
+export function reloadSettings(ctx) {
+    try {
+        ctx.loaded = loadConfig(ctx.loaded.configPath ?? ctx.options.config);
+    }
+    catch {
+        // Broken settings file: keep what is loaded.
+    }
+}
 /** Another user's sandbox asks for their name to be typed: through `io`, so every surface can ask it. */
 export function typedConfirm(io) {
     return (prompt, expected) => io.confirm({

package/dist/app/features/accounts/accounts.def.d.ts

@@ -76,6 +76,10 @@ export declare const AccountsListSchema: z.ZodObject<{
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        fromPc: z.ZodBoolean;
+        hasFileSource: z.ZodBoolean;
+        onPc: z.ZodNullable<z.ZodBoolean>;
+        sandboxOnly: z.ZodBoolean;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -125,6 +129,10 @@ export declare const listAccounts: import("../../kernel/define.js").QueryDef<z.Z
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        fromPc: z.ZodBoolean;
+        hasFileSource: z.ZodBoolean;
+        onPc: z.ZodNullable<z.ZodBoolean>;
+        sandboxOnly: z.ZodBoolean;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>, "accounts.list">;
@@ -215,6 +223,10 @@ export declare const accountsView: import("../../kernel/define.js").ViewDef<{
             canImport: z.ZodBoolean;
             canLogin: z.ZodBoolean;
             needsFile: z.ZodBoolean;
+            fromPc: z.ZodBoolean;
+            hasFileSource: z.ZodBoolean;
+            onPc: z.ZodNullable<z.ZodBoolean>;
+            sandboxOnly: z.ZodBoolean;
             ready: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>, "accounts.list">;
@@ -240,6 +252,10 @@ export declare const accountsView: import("../../kernel/define.js").ViewDef<{
             canImport: z.ZodBoolean;
             canLogin: z.ZodBoolean;
             needsFile: z.ZodBoolean;
+            fromPc: z.ZodBoolean;
+            hasFileSource: z.ZodBoolean;
+            onPc: z.ZodNullable<z.ZodBoolean>;
+            sandboxOnly: z.ZodBoolean;
             ready: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>, "accounts.services">;

package/dist/app/features/accounts/accounts.run.d.ts

@@ -40,6 +40,10 @@ export declare const listAccountsRun: import("../../kernel/define.js").Implement
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        fromPc: import("zod").ZodBoolean;
+        hasFileSource: import("zod").ZodBoolean;
+        onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+        sandboxOnly: import("zod").ZodBoolean;
         ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.list">, import("../../../cli/commands/context.js").Context>;

package/dist/app/features/accounts/services.def.d.ts

@@ -21,6 +21,10 @@ export declare const ServiceRowSchema: z.ZodObject<{
     canImport: z.ZodBoolean;
     canLogin: z.ZodBoolean;
     needsFile: z.ZodBoolean;
+    fromPc: z.ZodBoolean;
+    hasFileSource: z.ZodBoolean;
+    onPc: z.ZodNullable<z.ZodBoolean>;
+    sandboxOnly: z.ZodBoolean;
     ready: z.ZodBoolean;
 }, z.core.$strip>;
 export type ServiceRow = z.output<typeof ServiceRowSchema>;
@@ -44,6 +48,10 @@ export declare const ServicesListSchema: z.ZodObject<{
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        fromPc: z.ZodBoolean;
+        hasFileSource: z.ZodBoolean;
+        onPc: z.ZodNullable<z.ZodBoolean>;
+        sandboxOnly: z.ZodBoolean;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -72,12 +80,17 @@ export declare const listServices: import("../../kernel/define.js").QueryDef<z.Z
         canImport: z.ZodBoolean;
         canLogin: z.ZodBoolean;
         needsFile: z.ZodBoolean;
+        fromPc: z.ZodBoolean;
+        hasFileSource: z.ZodBoolean;
+        onPc: z.ZodNullable<z.ZodBoolean>;
+        sandboxOnly: z.ZodBoolean;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>, "accounts.services">;
 export declare const serviceImport: import("../../kernel/define.js").OperationDef<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     from: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     message: z.ZodString;
 }, z.core.$strip>, "accounts.service.import">;
@@ -95,6 +108,7 @@ export declare const serviceLogout: import("../../kernel/define.js").OperationDe
 export declare const SERVICE_OPERATIONS: readonly [import("../../kernel/define.js").OperationDef<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     from: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     message: z.ZodString;
 }, z.core.$strip>, "accounts.service.import">, import("../../kernel/define.js").OperationDef<z.ZodObject<{
@@ -109,7 +123,7 @@ export declare const SERVICE_OPERATIONS: readonly [import("../../kernel/define.j
 }, z.core.$strip>, "accounts.service.logout">];
 /** The category id of a service in the menu and its section id on the web. */
 export declare function serviceCategory(kind: string): string;
-/** One service's section: its facts, its warnings and its actions. */
+/** One service's section: a few short facts and its actions. The full warnings are asked before saving. */
 export declare function serviceSection(s: ServiceRow): Section;
 /** The sections of every service (appended to the accounts page on the web). */
 export declare function serviceSections(o: ServicesList): Section[];

package/dist/app/features/accounts/services.def.js

@@ -29,12 +29,19 @@ export const ServiceRowSchema = z.object({
     canImport: z.boolean().describe('It can be taken from this PC or a file (sandbox account import)'),
     canLogin: z.boolean().describe('It can be typed (sandbox account login)'),
     needsFile: z.boolean().describe('Importing it needs --from <file>'),
+    fromPc: z.boolean().describe("This PC's own program can give it (the next launch takes it when sharing is on)"),
+    hasFileSource: z.boolean().describe('It can be read from a file you name'),
+    onPc: z
+        .boolean()
+        .nullable()
+        .describe('This PC has one to take (null: it cannot be taken from this PC). Only the presence, never the sign-in'),
+    sandboxOnly: z.boolean().describe('Only a sandbox can give it: sign in once inside one and it is kept'),
     ready: z.boolean().describe('Its sign-in is written; false: the menu and the web leave it out (the CLI says coming)'),
 });
 export const ServicesListSchema = z.object({ services: z.array(ServiceRowSchema) });
 const STATE_TEXT = {
     none: 'not saved',
-    saved: 'saved (encrypted)',
+    saved: 'saved',
     unreadable: 'cannot be read',
 };
 const STATE_TONE = {
@@ -43,10 +50,10 @@ const STATE_TONE = {
     unreadable: 'danger',
 };
 const SOURCE_TEXT = {
-    pc: 'taken from this PC',
+    pc: 'from this PC',
     file: 'from a file',
-    typed: 'typed in',
-    sandbox: 'signed in (or renewed) in a sandbox',
+    typed: 'by typing it',
+    sandbox: 'from a sandbox',
 };
 const day = (iso) => (iso ? iso.slice(0, 10) : '');
 /** `sandbox account status`: one line per service. */
@@ -84,6 +91,7 @@ export const serviceImport = defineOperation({
     input: z.object({
         name: KindSchema,
         from: z.string().max(1000).optional().describe('(import) the file or folder to take the sign-in from'),
+        file: z.boolean().optional().describe('(import) ask for a file even when this PC has one to take'),
     }),
     output: MessageSchema,
     text: (o) => o.message,
@@ -113,7 +121,14 @@ export const SERVICE_OPERATIONS = [serviceImport, serviceLogin, serviceLogout];
 export function serviceCategory(kind) {
     return 'service:' + kind;
 }
-/** What can be done with one service: share or stop, import, sign in, forget. */
+/** What to do when this PC has no sign-in to take, by kind (short). */
+const PC_HELP = {
+    epic: 'Sign in to the Epic launcher here, with Remember me on.',
+    steam: 'Log in once with SteamCMD in C:\\steamcmd.',
+    unity: 'Sign in to the Unity Hub here.',
+    perplexity: 'Set PERPLEXITY_API_KEY for your Windows user.',
+};
+/** What can be done with one service: share or stop, take or import, type it, forget. Every one works from the menu. */
 function serviceActions(s) {
     return [
         action(setSetting, { scope: 'user', key: 'accounts.' + s.kind + '.share', value: !s.share }, {
@@ -122,61 +137,82 @@ function serviceActions(s) {
             label: s.share ? 'Stop sharing' : 'Share with sandboxes',
             importance: 1,
         }),
-        ...(s.canImport ? [action(serviceImport, { name: s.kind }, { key: 'i', verb: 'import', importance: 1 })] : []),
-        ...(s.canLogin ? [action(serviceLogin, { name: s.kind }, { key: 'n', verb: 'sign in', importance: 1 })] : []),
+        ...(s.fromPc
+            ? [
+                action(serviceImport, { name: s.kind }, { key: 'i', verb: 'take from this PC', label: "Take this PC's sign-in", importance: 1 }),
+            ]
+            : []),
+        ...(s.hasFileSource
+            ? [
+                action(serviceImport, { name: s.kind, file: true }, {
+                    key: s.fromPc ? 'f' : 'i',
+                    verb: 'import a file',
+                    label: 'Import from a file…',
+                    importance: s.fromPc ? 2 : 1,
+                }),
+            ]
+            : []),
+        ...(s.canLogin
+            ? [
+                action(serviceLogin, { name: s.kind }, { key: 'n', verb: 'type it in', label: 'Type the sign-in…', importance: 1 }),
+            ]
+            : []),
         ...(s.state !== 'none'
             ? [action(serviceLogout, { name: s.kind }, { key: 'x', verb: 'forget', importance: 2 })]
             : []),
     ];
 }
-/** How to get a first sign-in, in words (the actions below do it). */
-function howTo(s) {
-    const ways = [...(s.canImport ? ['import it'] : []), ...(s.canLogin ? ['type it in'] : [])];
-    return ways.length
-        ? ways.join(' or ')
-        : "sign in once inside a sandbox (it can't be copied from this PC: Windows locks it to your PC account)";
+/** The one line of help for a service: how to get its first sign-in, or what happens next. Short. */
+function helpLine(s) {
+    if (s.state !== 'none')
+        return undefined;
+    if (s.sandboxOnly)
+        return 'Sign in once inside a sandbox; it is kept for the next ones.';
+    if (s.fromPc && s.onPc)
+        return s.share ? "The next sandbox takes this PC's." : "Share it and the next sandbox takes this PC's.";
+    if (s.fromPc)
+        return PC_HELP[s.kind] ?? 'Not found on this PC.';
+    return s.canLogin ? 'Type it in, or import it from a file.' : 'Import it from a file.';
 }
-/** One service's section: its facts, its warnings and its actions. */
+/** One service's section: a few short facts and its actions. The full warnings are asked before saving. */
 export function serviceSection(s) {
     const facts = [
         {
             id: s.kind + ':share',
-            label: 'Shared with sandboxes',
+            label: 'Shared',
             value: s.share ? 'on' : 'off',
             tone: s.share ? 'ok' : 'muted',
-            description: 'For sandboxes that use ' + s.usedFor + '. ' + s.warnings.join(' '),
+            description: 'The agent can use it.',
         },
         {
             id: s.kind + ':state',
             label: 'Sign-in',
             value: STATE_TEXT[s.state] + (s.savedAt ? '  ' + day(s.savedAt) : ''),
             tone: STATE_TONE[s.state],
-            description: s.state === 'none' ? 'Save one: ' + howTo(s) + '.' : undefined,
+            description: s.state === 'unreadable'
+                ? 'Only the Windows user that saved it can read it: save it again.'
+                : (helpLine(s) ?? (s.source ? 'Saved ' + (SOURCE_TEXT[s.source] ?? s.source) + '.' : undefined)),
         },
-        ...(s.source ? [{ id: s.kind + ':source', label: 'From', value: SOURCE_TEXT[s.source] ?? s.source }] : []),
+        ...(s.onPc === null
+            ? []
+            : [
+                {
+                    id: s.kind + ':pc',
+                    label: 'On this PC',
+                    value: s.onPc ? 'found' : 'not found',
+                    tone: s.onPc ? 'ok' : 'muted',
+                },
+            ]),
         ...(s.summary ? [{ id: s.kind + ':summary', label: 'Account', value: s.summary }] : []),
         ...(s.heldBy
             ? [{ id: s.kind + ':held', label: 'In use by', value: 'sandbox ' + s.heldBy, tone: 'accent' }]
             : []),
     ];
-    const warnings = s.warnings.map((w, i) => ({
-        id: s.kind + ':warning:' + i,
-        label: w,
-        tone: 'warn',
-        group: 'Before you share it',
-    }));
-    const notes = [
-        ...(s.state === 'unreadable'
-            ? [{ text: 'Only the Windows user that saved it can read it: save it again.', tone: 'muted' }]
-            : []),
-    ];
     return {
         id: serviceCategory(s.kind),
         title: s.label,
         summary: (s.share ? 'shared' : 'not shared') + ' · ' + STATE_TEXT[s.state],
         facts,
-        items: warnings,
-        notes,
         actions: serviceActions(s),
     };
 }

package/dist/app/features/accounts/services.run.d.ts

@@ -4,14 +4,14 @@ import { type ServiceKind } from '../../../shared/accounts/index.js';
 import { type OperationIO } from '../../kernel/index.js';
 import { type ServiceRow } from './services.def.js';
 /** One service's row: never the sign-in, and the store's summary through safeText. */
-export declare function serviceRow(kind: ServiceKind, config: Config, store: ServiceAccountStore, leases: AccountLeases): ServiceRow;
+export declare function serviceRow(kind: ServiceKind, config: Config, store: ServiceAccountStore, leases: AccountLeases, pc?: PcEnv): ServiceRow;
 export interface ImportDeps {
     readonly store: ServiceAccountStore;
     readonly pc: PcEnv;
     readonly share: boolean;
 }
 /** Saves a kind's sign-in from this PC's program or from a file, after a confirmation (--yes answers it). */
-export declare function importServiceFlow(io: OperationIO, kind: ServiceKind, from: string | undefined, deps: ImportDeps): Promise<{
+export declare function importServiceFlow(io: OperationIO, kind: ServiceKind, from: string | undefined, deps: ImportDeps, wantFile?: boolean): Promise<{
     message: string;
 }>;
 /** Saves what you type for a kind (a key, a token). */
@@ -45,12 +45,17 @@ export declare const listServicesRun: import("../../kernel/define.js").Implement
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        fromPc: import("zod").ZodBoolean;
+        hasFileSource: import("zod").ZodBoolean;
+        onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+        sandboxOnly: import("zod").ZodBoolean;
         ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.services">, import("../../../cli/commands/context.js").Context>;
 export declare const serviceImportRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
     name: import("zod").ZodOptional<import("zod").ZodString>;
     from: import("zod").ZodOptional<import("zod").ZodString>;
+    file: import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "accounts.service.import">, import("../../../cli/commands/context.js").Context>;

package/dist/app/features/accounts/services.run.js

@@ -12,8 +12,22 @@ import { implement } from '../../context.js';
 import { cancelled } from '../../kernel/index.js';
 import { isKindReady } from '../../../shared/readiness.js';
 import { listServices, serviceImport, serviceLogin, serviceLogout } from './services.def.js';
+/** Does this PC have a sign-in to take? Only whether, never what: the payload is dropped at once. */
+function presentOnPc(kind, pc) {
+    const source = HOST_SOURCES[kind];
+    if (!source.fromPc)
+        return null;
+    if (!pc)
+        return false;
+    try {
+        return source.fromPc(pc) !== null;
+    }
+    catch {
+        return false; // This PC's program has no usable sign-in.
+    }
+}
 /** One service's row: never the sign-in, and the store's summary through safeText. */
-export function serviceRow(kind, config, store, leases) {
+export function serviceRow(kind, config, store, leases, pc) {
     const spec = SERVICE_SPECS[kind];
     const source = HOST_SOURCES[kind];
     const state = store.state(kind);
@@ -34,6 +48,10 @@ export function serviceRow(kind, config, store, leases) {
         canImport: Boolean(source.fromPc || source.fromFile),
         canLogin: Boolean(source.fromAnswers),
         needsFile: Boolean(source.fromFile && !source.fromPc),
+        fromPc: Boolean(source.fromPc),
+        hasFileSource: Boolean(source.fromFile),
+        onPc: presentOnPc(kind, pc),
+        sandboxOnly: !source.fromPc && !source.fromFile && !source.fromAnswers,
         ready: isKindReady(kind),
     };
 }
@@ -93,7 +111,7 @@ function savedMessage(kind, share) {
         (share ? '' : ' Sandboxes get it once you turn on Share with sandboxes.'));
 }
 /** Saves a kind's sign-in from this PC's program or from a file, after a confirmation (--yes answers it). */
-export async function importServiceFlow(io, kind, from, deps) {
+export async function importServiceFlow(io, kind, from, deps, wantFile = false) {
     const spec = SERVICE_SPECS[kind];
     const source = HOST_SOURCES[kind];
     if (!source.fromPc && !source.fromFile)
@@ -102,7 +120,7 @@ export async function importServiceFlow(io, kind, from, deps) {
         failWith(spec.label + ' cannot be imported.', 'Type it instead.', {
             op: 'accounts.service.login',
             input: { name: kind },
-            label: 'Sign in…',
+            label: 'Type the sign-in…',
             cli: 'sandbox account login ' + kind,
         });
     let file = from === undefined ? undefined : path.resolve(from);
@@ -114,7 +132,7 @@ export async function importServiceFlow(io, kind, from, deps) {
             return false;
         }
     };
-    const useFile = Boolean(source.fromFile && (file ? isFile(file) : !source.fromPc));
+    const useFile = Boolean(source.fromFile && (file ? isFile(file) : wantFile || !source.fromPc));
     if (useFile && !file) {
         const asked = await io.path({ title: 'The ' + spec.label + ' file:', pathKind: 'file' });
         if (asked === undefined)
@@ -214,7 +232,8 @@ export const listServicesRun = implement(listServices, async (ctx, input) => {
     if (name !== undefined && name !== '' && !isServiceKind(name))
         fail('There is no service called "' + safeText(input.name ?? '') + '".', 'Use one of: ' + SERVICE_KINDS.join(', '));
     const kinds = name ? [name] : [...SERVICE_KINDS];
-    return { services: kinds.map((k) => serviceRow(k, ctx.loaded.config, store, leases)) };
+    const pc = pcEnv();
+    return { services: kinds.map((k) => serviceRow(k, ctx.loaded.config, store, leases, pc)) };
 });
 export const serviceImportRun = implement(serviceImport, async (ctx, input, io) => {
     requireOnPc('account import');
@@ -223,7 +242,7 @@ export const serviceImportRun = implement(serviceImport, async (ctx, input, io)
         store: new ServiceAccountStore(ctx.storageRoot),
         pc: pcEnv(),
         share: ctx.loaded.config.accounts[kind].share,
-    });
+    }, input.file ?? false);
 });
 export const serviceLoginRun = implement(serviceLogin, async (ctx, input, io) => {
     requireOnPc('account login');

package/dist/app/features/defs.d.ts

@@ -308,6 +308,7 @@ export declare const OPERATIONS: readonly [OperationDef<import("zod").ZodObject<
 }, import("zod/v4/core").$strip>, "github.logout">, OperationDef<import("zod").ZodObject<{
     name: import("zod").ZodOptional<import("zod").ZodString>;
     from: import("zod").ZodOptional<import("zod").ZodString>;
+    file: import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "accounts.service.import">, OperationDef<import("zod").ZodObject<{
@@ -615,6 +616,10 @@ export declare const QUERIES: readonly [QueryDef<import("zod").ZodObject<{}, imp
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        fromPc: import("zod").ZodBoolean;
+        hasFileSource: import("zod").ZodBoolean;
+        onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+        sandboxOnly: import("zod").ZodBoolean;
         ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.list">, QueryDef<import("zod").ZodObject<{
@@ -1084,6 +1089,10 @@ export declare const QUERIES: readonly [QueryDef<import("zod").ZodObject<{}, imp
         canImport: import("zod").ZodBoolean;
         canLogin: import("zod").ZodBoolean;
         needsFile: import("zod").ZodBoolean;
+        fromPc: import("zod").ZodBoolean;
+        hasFileSource: import("zod").ZodBoolean;
+        onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+        sandboxOnly: import("zod").ZodBoolean;
         ready: import("zod").ZodBoolean;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "accounts.services">, QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -1532,6 +1541,10 @@ export declare const VIEWS: readonly [import("../kernel/define.js").ViewDef<{
             canImport: import("zod").ZodBoolean;
             canLogin: import("zod").ZodBoolean;
             needsFile: import("zod").ZodBoolean;
+            fromPc: import("zod").ZodBoolean;
+            hasFileSource: import("zod").ZodBoolean;
+            onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            sandboxOnly: import("zod").ZodBoolean;
             ready: import("zod").ZodBoolean;
         }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, "accounts.list">;
@@ -1557,6 +1570,10 @@ export declare const VIEWS: readonly [import("../kernel/define.js").ViewDef<{
             canImport: import("zod").ZodBoolean;
             canLogin: import("zod").ZodBoolean;
             needsFile: import("zod").ZodBoolean;
+            fromPc: import("zod").ZodBoolean;
+            hasFileSource: import("zod").ZodBoolean;
+            onPc: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            sandboxOnly: import("zod").ZodBoolean;
             ready: import("zod").ZodBoolean;
         }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, "accounts.services">;

package/dist/app/registry.d.ts

@@ -1,4 +1,4 @@
-import type { AppContext } from './context.js';
+import { type AppContext } from './context.js';
 import { type AnyDefinition, type Implementation, type OperationIO, type OutputOf, type QueryDef, type RpcHost } from './kernel/index.js';
 export declare const IMPLEMENTATIONS: readonly Implementation<AnyDefinition, AppContext>[];
 export declare function implementationOf(id: string): Implementation<AnyDefinition, AppContext> | undefined;

package/dist/app/registry.js

@@ -1,3 +1,6 @@
+// Every feature's implementation, by id (Node side; features/defs.ts is the pure half the browser uses). Surfaces run
+// definitions only through here, so input and output are checked the same way everywhere.
+import { reloadSettings } from './context.js';
 import { fail } from '../core/util/errors.js';
 import { accessNeeded, allows, invoke, OWNER, refusalText, NO_QUESTIONS, onSurface, } from './kernel/index.js';
 import { addAgentRun, agentEnvRun, agentsEnvSetRun, listAgentsRun, makeDefaultAgentRun, removeAgentRun, startAgentRun, } from './features/agents/index.js';
@@ -129,7 +132,17 @@ export function runDefinition(id, ctx, input, io) {
     const impl = implementationOf(id);
     if (!impl)
         throw new Error('No implementation for ' + id);
-    return invoke(impl, ctx, input, io);
+    return invokeAndRefresh(impl, ctx, input, io);
+}
+/** invoke(), then reads the settings again after an operation: the next read of any page sees what it saved. */
+async function invokeAndRefresh(impl, ctx, input, io) {
+    try {
+        return await invoke(impl, ctx, input, io);
+    }
+    finally {
+        if (impl.def.kind === 'operation')
+            reloadSettings(ctx);
+    }
 }
 /** Reads a query in-process (the menu): typed output, and no questions. */
 export async function readQuery(def, ctx, input = {}) {
@@ -161,7 +174,7 @@ export function createRpcHost(ctx) {
             const need = accessNeeded(impl.def, input);
             if (!allows(caller, need))
                 fail(refusalText(caller, need));
-            return invoke(impl, ctx, input, io);
+            return invokeAndRefresh(impl, ctx, input, io);
         },
     };
 }

package/dist/bin/agent-sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-QUHNXHVG.js";
-import "./chunk-RSIX7C6D.js";
+} from "./chunk-4M5SZZ5P.js";
+import "./chunk-RU7XRN62.js";
 
 // src/bin/agent-sandbox.ts
 run(process.argv.slice(2));