windows-development-sandbox 1.13.0 → 1.13.2

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

@@ -76,6 +76,7 @@ export declare const useAccount: import("../../kernel/define.js").OperationDef<z
 export declare const defaultAccount: import("../../kernel/define.js").OperationDef<z.ZodObject<{
     agent: z.ZodDefault<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
+    noRestart: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     message: z.ZodString;
 }, z.core.$strip>, "accounts.default">;

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

@@ -103,11 +103,20 @@ export const useAccount = defineOperation({
 export const defaultAccount = defineOperation({
     id: 'accounts.default',
     title: 'Make default',
-    summary: 'the login new launches start with',
-    input: z.object({ agent: AgentSchema, name: NameSchema }),
+    summary: 'the login every launch starts with; the sandbox switches to it now too',
+    input: z.object({
+        agent: AgentSchema,
+        name: NameSchema,
+        noRestart: z.boolean().default(false).describe('(default) do not restart running sessions'),
+    }),
     output: MessageSchema,
     text: (o) => o.message,
-    cli: { name: 'account', action: 'default', positional: ['name'], flags: { agent: { flag: '--agent' } } },
+    cli: {
+        name: 'account',
+        action: 'default',
+        positional: ['name'],
+        flags: { agent: { flag: '--agent' }, noRestart: { flag: '--no-restart' } },
+    },
 });
 export const renameAccount = defineOperation({
     id: 'accounts.rename',

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

@@ -33,6 +33,7 @@ export declare const useAccountRun: import("../../kernel/define.js").Implementat
 export declare const defaultAccountRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
     agent: import("zod").ZodDefault<import("zod").ZodString>;
     name: import("zod").ZodOptional<import("zod").ZodString>;
+    noRestart: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "accounts.default">, import("../../../cli/commands/context.js").Context>;

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

@@ -71,32 +71,41 @@ export const saveAccountRun = implement(saveAccount, async (ctx, input, io) => {
     const saved = service.save(name, input.fromHost, input.agent);
     return { name: saved.name, message: 'Saved account ' + label(saved) + '.' };
 });
-export const useAccountRun = implement(useAccount, async (ctx, input, io) => {
-    const service = new AccountsService(ctx);
-    const name = await accountName(io, service, 'use', input.agent, input.name);
-    // The switch is done before the question: a "no" to the restart keeps the new login and only skips the restart.
-    const used = service.activate(name, input.agent);
+/**
+ * Makes the sandbox use a saved login, then offers to restart the agent's running sessions. The switch is done before
+ * the question: a "no" keeps the new login and only skips the restart.
+ */
+async function switchTo(io, service, name, agent, noRestart) {
+    const used = service.activate(name, agent);
     const lines = ['Sandbox now uses ' + label(used) + '.'];
     if (used.note)
         lines.push(safeText(used.note));
-    if (service.hasRunningSessions(input.agent) && !input.noRestart) {
+    if (service.hasRunningSessions(agent) && !noRestart) {
         const restart = await io.confirm({
-            title: 'Restart the running ' + input.agent + ' sessions?',
+            title: 'Restart the running ' + agent + ' sessions?',
             lines: ['They restart and continue their conversation where the agent can, now under the new login.'],
             yes: 'Restart',
             implied: true,
         });
         if (restart)
-            lines.push(safeText(await service.restart(input.agent)) +
-                ' with --continue; the conversation carries on under the new account.');
+            lines.push(safeText(await service.restart(agent)) + ' with --continue; the conversation carries on under the new account.');
     }
-    return { lines };
+    return lines;
+}
+export const useAccountRun = implement(useAccount, async (ctx, input, io) => {
+    const service = new AccountsService(ctx);
+    const name = await accountName(io, service, 'use', input.agent, input.name);
+    return { lines: await switchTo(io, service, name, input.agent, input.noRestart) };
 });
 export const defaultAccountRun = implement(defaultAccount, async (ctx, input, io) => {
     const service = new AccountsService(ctx);
     const name = await accountName(io, service, 'default', input.agent, input.name);
     service.setDefault(name, input.agent);
-    return { message: 'Default account: ' + name };
+    const lines = ['Default account: ' + name];
+    // The sandbox follows the new default at once (not only from the next launch).
+    if (service.activeName(input.agent) !== name)
+        lines.push(...(await switchTo(io, service, name, input.agent, input.noRestart)));
+    return { message: lines.join('\n') };
 });
 export const renameAccountRun = implement(renameAccount, async (ctx, input, io) => {
     const service = new AccountsService(ctx);

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

@@ -111,6 +111,7 @@ export declare const OPERATIONS: readonly [OperationDef<import("zod").ZodObject<
 }, import("zod/v4/core").$strip>, "accounts.use">, OperationDef<import("zod").ZodObject<{
     agent: import("zod").ZodDefault<import("zod").ZodString>;
     name: import("zod").ZodOptional<import("zod").ZodString>;
+    noRestart: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "accounts.default">, OperationDef<import("zod").ZodObject<{

package/dist/app/features/settings/settings-file.d.ts

@@ -22,6 +22,8 @@ export declare class ConfigFile {
     readonly target: SettingsTarget;
     readonly file: string;
     readonly schema: SchemaNode;
+    /** The file as read in this synchronous run (see read). */
+    private snapshot;
     constructor(target: SettingsTarget, file: string);
     static user(configPath: string | null): ConfigFile;
     static project(dir: string): ConfigFile;
@@ -30,6 +32,11 @@ export declare class ConfigFile {
     text(): string;
     /** The value written in this file (undefined = not set here). */
     valueInFile(key: string[]): unknown;
+    /**
+     * The file's text and what it parses to, read once per synchronous run: the settings list asks for every setting's
+     * value (hundreds of reads), and the next run (after a key, a save or a change outside) reads the file again.
+     */
+    private read;
     /** Your own settings with the built-in defaults filled in (what a sandbox uses without a project file). */
     userConfig(): Config;
     /** What is in effect: for your file the merged config, for a project file only what the file sets. */

package/dist/app/features/settings/settings-file.js

@@ -34,6 +34,8 @@ export class ConfigFile {
     target;
     file;
     schema;
+    /** The file as read in this synchronous run (see read). */
+    snapshot;
     constructor(target, file) {
         this.target = target;
         this.file = file;
@@ -52,11 +54,25 @@ export class ConfigFile {
         return fs.existsSync(this.file);
     }
     text() {
-        return this.exists ? fs.readFileSync(this.file, 'utf8') : '';
+        return this.read().text;
     }
     /** The value written in this file (undefined = not set here). */
     valueInFile(key) {
-        return fileValue(this.text(), key);
+        const value = _.get(this.read().parsed, key);
+        // A copy: the parsed file is shared by every read in this run.
+        return value !== null && typeof value === 'object' ? structuredClone(value) : value;
+    }
+    /**
+     * The file's text and what it parses to, read once per synchronous run: the settings list asks for every setting's
+     * value (hundreds of reads), and the next run (after a key, a save or a change outside) reads the file again.
+     */
+    read() {
+        if (!this.snapshot) {
+            const text = this.exists ? fs.readFileSync(this.file, 'utf8') : '';
+            this.snapshot = { text, parsed: parse(text) ?? {} };
+            queueMicrotask(() => (this.snapshot = undefined));
+        }
+        return this.snapshot;
     }
     /** Your own settings with the built-in defaults filled in (what a sandbox uses without a project file). */
     userConfig() {
@@ -100,6 +116,7 @@ export class ConfigFile {
             return 'unchanged';
         fs.mkdirSync(path.dirname(this.file), { recursive: true });
         fs.writeFileSync(this.file, text, 'utf8');
+        this.snapshot = undefined;
         return 'saved';
     }
 }

package/dist/app/features/settings/settings-rows.js

@@ -46,9 +46,17 @@ export function masked(key, value) {
         return undefined;
     return _.get(redactSecrets(_.set({}, key, structuredClone(value))), key);
 }
+/** The keys a project file's schema can set, worked out once per schema (a list asks for it on every row). */
+const projectKeysOf = new WeakMap();
 /** The keys a project file can set. */
 function projectKeys(files) {
-    return new Set(files.project.schema.leaves().map((l) => l.key.join('.')));
+    const schema = files.project.schema;
+    let keys = projectKeysOf.get(schema);
+    if (!keys) {
+        keys = new Set(schema.leaves().map((l) => l.key.join('.')));
+        projectKeysOf.set(schema, keys);
+    }
+    return keys;
 }
 /** One setting's row in a scope (`config` and `inProject` can be passed when making many rows). */
 export function settingRow(s, files, scope, source = SAVED, config = files.user.userConfig(), inProject = projectKeys(files)) {

package/dist/bin/agent-sandbox.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
-import { run } from '../cli/index.js';
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  run
+} from "./chunk-K4SU3MHJ.js";
+import "./chunk-VENWSGX2.js";
+
+// src/bin/agent-sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/chunk-IL7BXJF2.js

@@ -0,0 +1,7 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  attach
+} from "./chunk-VENWSGX2.js";
+export {
+  attach
+};