windows-development-sandbox 1.12.0 → 1.13.2

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

@@ -0,0 +1,129 @@
+// Remote access's work (docs/design/remote-access.md): the access list in <storage>\web\access.json (shared with the
+// running web server, which reads it again when it changes and closes the pages of whoever was signed out), the
+// remote settings, the firewall rule and the network check of LAN mode. The one-time code is returned once and only
+// its hash is kept.
+import { requireOnPc } from '../../../cli/commands/context.js';
+import { fail } from '../../../core/util/index.js';
+import { AccessStore, addRuleRequest, applyFirewall, chooseLanAddress, lanUrl, networkProblem, networkProfile, removeRuleRequest, showCode, } from '../../../host/remote/index.js';
+import { SecretStore } from '../../../host/secrets/index.js';
+import { protectPrivateFolder } from '../../../host/sharing/index.js';
+import { selfTestRunning } from '../../../host/test-guard.js';
+import { WebStore } from '../../../host/web/index.js';
+import { implement } from '../../context.js';
+import { ConfigFile } from '../settings/index.js';
+import { accessStatus, allowDevice, lanOff, lanOn, revokeAccess, revokeAllAccess } from './access.def.js';
+/** The access list of this user (the folder is the web state's private one). */
+export function accessStoreOf(ctx) {
+    return AccessStore.at(ctx.storageRoot, SecretStore.standard(), {
+        // The self-test never changes folder permissions; its storage is a temp folder.
+        protect: selfTestRunning() ? undefined : (dir) => protectPrivateFolder(dir),
+    });
+}
+function lanStateOf(ctx) {
+    const lan = new WebStore(ctx.storageRoot).read()?.lan;
+    return { url: lan?.url ?? null, fingerprint: lan?.fingerprint ?? null, problem: lan?.problem ?? null };
+}
+function setLan(ctx, enabled) {
+    const outcome = ConfigFile.user(ctx.loaded.configPath).set(['web', 'remote', 'lan', 'enabled'], enabled);
+    if (typeof outcome === 'object')
+        fail('Could not change web.remote.lan.enabled: ' + outcome.problems.join('; '));
+}
+export const accessStatusRun = implement(accessStatus, (ctx) => {
+    requireOnPc('web');
+    const remote = ctx.loaded.config.web.remote;
+    const data = accessStoreOf(ctx).read();
+    const now = Date.now();
+    const alive = (iso) => Date.parse(iso) > now;
+    const lan = lanStateOf(ctx);
+    return {
+        lan: {
+            enabled: remote.lan.enabled,
+            running: remote.lan.enabled && lan.url !== null,
+            address: remote.lan.enabled ? lan.url : null,
+            fingerprint: remote.lan.enabled ? lan.fingerprint : null,
+            problem: remote.lan.enabled ? lan.problem : null,
+            network: data.network,
+        },
+        windowsSignIn: remote.windowsSignIn,
+        users: remote.users.map((u) => ({ name: u.name, role: u.role })),
+        rememberDays: remote.rememberDays,
+        devices: data.devices
+            .filter((d) => alive(d.expiresAt))
+            .map((d) => ({
+            id: d.id,
+            name: d.name,
+            role: d.role,
+            address: d.address,
+            createdAt: d.createdAt,
+            expiresAt: d.expiresAt,
+            lastSeen: d.lastSeen ?? null,
+        })),
+        windows: data.windows
+            .filter((w) => alive(w.expiresAt))
+            .map((w) => ({ id: w.id, user: w.user, createdAt: w.createdAt, expiresAt: w.expiresAt })),
+        pending: data.code && alive(data.code.expiresAt) ? { role: data.code.role, expiresAt: data.code.expiresAt } : null,
+        codeVoided: data.codeVoided,
+    };
+});
+export const allowDeviceRun = implement(allowDevice, (ctx, input) => {
+    requireOnPc('web');
+    if (!ctx.loaded.config.web.remote.lan.enabled)
+        fail('LAN mode is off, so no device on your network can reach the web UI.', 'Turn it on first: sandbox web lan-on');
+    const { code, expiresAt } = accessStoreOf(ctx).newDeviceCode(input.role);
+    const lan = lanStateOf(ctx);
+    return { code: showCode(code), expiresAt, role: input.role, address: lan.url, fingerprint: lan.fingerprint };
+});
+export const revokeAccessRun = implement(revokeAccess, (ctx, input) => {
+    requireOnPc('web');
+    if (!accessStoreOf(ctx).revoke(input.id))
+        fail('There is no device or sign-in ' + input.id + '.', 'See sandbox web devices.');
+    return { message: 'Signed out. Its open pages close within half a minute.' };
+});
+export const revokeAllAccessRun = implement(revokeAllAccess, async (ctx, _input, io) => {
+    requireOnPc('web');
+    const ok = await io.confirm({
+        title: 'Sign out every device and Windows user now?',
+        danger: true,
+        yes: 'Sign out all',
+    });
+    if (!ok)
+        return { message: 'Nothing changed.' };
+    accessStoreOf(ctx).revokeAll('everything');
+    return { message: 'Everyone is signed out, and a code not used yet is void.' };
+});
+export const lanOnRun = implement(lanOn, async (ctx, _input, io) => {
+    requireOnPc('web');
+    const lan = ctx.loaded.config.web.remote.lan;
+    const bound = chooseLanAddress(lan.address);
+    io.progress('Checking the network');
+    const profile = await networkProfile(bound.address);
+    const problem = networkProblem(profile, null);
+    if (problem)
+        fail(problem, 'LAN mode only runs on a network you marked Private (Windows Settings > Network > your network).');
+    io.progress('Adding the firewall rule (Windows asks for permission)');
+    await applyFirewall(addRuleRequest(lan.port, bound.address));
+    accessStoreOf(ctx).setNetwork(profile.name);
+    setLan(ctx, true);
+    const address = lanUrl(bound.address, lan.port);
+    return {
+        address,
+        message: 'LAN mode is on for the network "' +
+            profile.name +
+            '": devices open ' +
+            address +
+            ' (the running web UI starts listening within half a minute). Next: Allow a new device.',
+    };
+});
+export const lanOffRun = implement(lanOff, async (ctx, _input, io) => {
+    requireOnPc('web');
+    const ok = await io.confirm({ title: 'Turn off LAN mode and sign out every device?', danger: true, yes: 'Turn off' });
+    if (!ok)
+        return { message: 'Nothing changed.' };
+    setLan(ctx, false);
+    const store = accessStoreOf(ctx);
+    store.revokeAll('devices');
+    store.setNetwork(null);
+    io.progress('Removing the firewall rule (Windows asks for permission)');
+    await applyFirewall(removeRuleRequest());
+    return { message: 'LAN mode is off: the firewall rule is gone and every device is signed out.' };
+});

package/dist/app/features/access/index.d.ts

@@ -0,0 +1,2 @@
+export * from './access.def.js';
+export * from './access.run.js';

package/dist/app/features/access/index.js

@@ -0,0 +1,3 @@
+// Remote access: devices on your network and other Windows users of this PC (docs/design/remote-access.md).
+export * from './access.def.js';
+export * from './access.run.js';

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/agents/agent-entry.js

@@ -2,6 +2,8 @@
 // adding and removing one change. Node side (it checks names with the config schema); the agents run writes them.
 import { DEFAULTS } from '../../../core/config/index.js';
 import { HarnessSchema, NameSchema, describeIssues } from '../../../core/schema/index.js';
+/** Names an agent cannot have. */
+const RESERVED = ['shell', 'pwsh', 'powershell', 'cmd', 'close'];
 /** Nothing wrong with the name (true), or what is wrong. Pure. */
 export function agentNameProblem(name, taken) {
     const typed = name.trim();
@@ -12,6 +14,9 @@ export function agentNameProblem(name, taken) {
         return 'Use letters, numbers, - and _ only.';
     if (taken.some((t) => t.toLowerCase() === typed.toLowerCase()))
         return typed + ' is an agent already.';
+    // Shell sessions are listed by these names, and sandbox shell / close are commands.
+    if (RESERVED.includes(typed.toLowerCase()))
+        return typed + ' is taken by the sandbox; choose another name.';
     return true;
 }
 /** The command a package usually provides: "@scope/my-agent@latest" gives "my-agent". Pure. */

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

@@ -25,6 +25,7 @@ export const listAgents = defineQuery({
 });
 export const startAgent = defineOperation({
     id: 'agents.start',
+    access: 'control',
     title: 'Start an agent',
     summary: 'start an agent in a project of the running sandbox',
     input: z.object({

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

@@ -145,6 +145,7 @@ export const setCustomApps = defineOperation({
 });
 export const requestApp = defineOperation({
     id: 'apps.request',
+    access: 'control',
     title: 'Request an app…',
     summary: 'open a prefilled GitHub request for an app that is not in the list',
     input: z.object({}),

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

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { type Page } from '../../kernel/index.js';
-export declare const AUDIT_EVENT_KINDS: readonly ["proc", "file", "commit", "session", "guard", "note"];
-export declare const AUDIT_KIND_FILTERS: readonly ["all", "proc", "file", "commit", "session", "guard"];
+export declare const AUDIT_EVENT_KINDS: readonly ["proc", "file", "commit", "session", "guard", "note", "remote"];
+export declare const AUDIT_KIND_FILTERS: readonly ["all", "proc", "file", "commit", "session", "guard", "remote"];
 /** The session filter that means "not linked to any session". */
 export declare const NO_SESSION = "none";
 export declare const AuditRowSchema: z.ZodObject<{
     time: z.ZodString;
     kind: z.ZodEnum<{
         file: "file";
+        remote: "remote";
         session: "session";
         note: "note";
         commit: "commit";
@@ -60,6 +61,7 @@ export declare const AuditListSchema: z.ZodObject<{
         days: z.ZodNumber;
         kind: z.ZodEnum<{
             file: "file";
+            remote: "remote";
             all: "all";
             session: "session";
             commit: "commit";
@@ -76,6 +78,7 @@ export declare const AuditListSchema: z.ZodObject<{
         time: z.ZodString;
         kind: z.ZodEnum<{
             file: "file";
+            remote: "remote";
             session: "session";
             note: "note";
             commit: "commit";
@@ -134,6 +137,7 @@ export declare const listAudit: import("../../kernel/define.js").QueryDef<z.ZodO
     days: z.ZodDefault<z.ZodNumber>;
     kind: z.ZodDefault<z.ZodEnum<{
         file: "file";
+        remote: "remote";
         all: "all";
         session: "session";
         commit: "commit";
@@ -155,6 +159,7 @@ export declare const listAudit: import("../../kernel/define.js").QueryDef<z.ZodO
         days: z.ZodNumber;
         kind: z.ZodEnum<{
             file: "file";
+            remote: "remote";
             all: "all";
             session: "session";
             commit: "commit";
@@ -171,6 +176,7 @@ export declare const listAudit: import("../../kernel/define.js").QueryDef<z.ZodO
         time: z.ZodString;
         kind: z.ZodEnum<{
             file: "file";
+            remote: "remote";
             session: "session";
             note: "note";
             commit: "commit";
@@ -248,6 +254,7 @@ export declare const auditView: import("../../kernel/define.js").ViewDef<{
         days: z.ZodDefault<z.ZodNumber>;
         kind: z.ZodDefault<z.ZodEnum<{
             file: "file";
+            remote: "remote";
             all: "all";
             session: "session";
             commit: "commit";
@@ -269,6 +276,7 @@ export declare const auditView: import("../../kernel/define.js").ViewDef<{
             days: z.ZodNumber;
             kind: z.ZodEnum<{
                 file: "file";
+                remote: "remote";
                 all: "all";
                 session: "session";
                 commit: "commit";
@@ -285,6 +293,7 @@ export declare const auditView: import("../../kernel/define.js").ViewDef<{
             time: z.ZodString;
             kind: z.ZodEnum<{
                 file: "file";
+                remote: "remote";
                 session: "session";
                 note: "note";
                 commit: "commit";

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

@@ -5,8 +5,8 @@
 import { z } from 'zod';
 import { action, ago, bytesText, defineQuery, defineView, link, plural, } from '../../kernel/index.js';
 import { setSetting } from '../settings/settings.def.js';
-export const AUDIT_EVENT_KINDS = ['proc', 'file', 'commit', 'session', 'guard', 'note'];
-export const AUDIT_KIND_FILTERS = ['all', 'proc', 'file', 'commit', 'session', 'guard'];
+export const AUDIT_EVENT_KINDS = ['proc', 'file', 'commit', 'session', 'guard', 'note', 'remote'];
+export const AUDIT_KIND_FILTERS = ['all', 'proc', 'file', 'commit', 'session', 'guard', 'remote'];
 /** The days the page offers (the log keeps at most 30). */
 const PERIODS = [1, 3, 7, 14, 30];
 /** The session filter that means "not linked to any session". */
@@ -20,12 +20,13 @@ const KIND_LABEL = {
     session: 'session',
     guard: 'GUARD',
     note: 'note',
+    remote: 'remote',
 };
 export const AuditRowSchema = z.object({
     time: z.string().describe('When it happened (ISO time)'),
     kind: z
         .enum(AUDIT_EVENT_KINDS)
-        .describe('proc: a program started; file: changed in a project; commit; session; guard: the repo guard; note'),
+        .describe('proc: a program started; file: changed in a project; commit; session; guard: the repo guard; note; remote: what another Windows user or a paired device did in the web UI'),
     what: z.string().describe('The program, the file, the commit message, the agent, or what happened'),
     command: z.string().optional().describe("A program's command line (secrets hidden)"),
     parent: z.string().optional().describe('The program that started it'),
@@ -43,7 +44,7 @@ export const AuditRowSchema = z.object({
         .describe('How it was linked: process = by the programs the session started; only-session = the only session running in that project then (likely, not proven)'),
     count: z.number().int().describe('How many times it happened in that minute'),
     sha: z.string().optional().describe("A commit's id"),
-    author: z.string().optional().describe("A commit's author"),
+    author: z.string().optional().describe("A commit's author; for remote: who did it"),
 });
 const CountsSchema = z.object({
     commands: z.number().int().describe('Programs started'),
@@ -152,6 +153,8 @@ export function eventWhat(e) {
                 (e.action && e.action !== 'commit' ? ' (' + e.action + ')' : ''));
         case 'session':
             return e.what + (e.action === 'end' ? ' ended' : ' started') + (e.project ? ' in ' + e.project : '');
+        case 'remote':
+            return (e.author ?? 'someone') + ': ' + e.what + (e.action && e.action !== 'ok' ? ' (' + e.action + ')' : '');
         default:
             return e.what;
     }

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

@@ -14,6 +14,7 @@ export declare const listAuditRun: import("../../kernel/define.js").Implementati
     days: import("zod").ZodDefault<import("zod").ZodNumber>;
     kind: import("zod").ZodDefault<import("zod").ZodEnum<{
         file: "file";
+        remote: "remote";
         all: "all";
         session: "session";
         commit: "commit";
@@ -35,6 +36,7 @@ export declare const listAuditRun: import("../../kernel/define.js").Implementati
         days: import("zod").ZodNumber;
         kind: import("zod").ZodEnum<{
             file: "file";
+            remote: "remote";
             all: "all";
             session: "session";
             commit: "commit";
@@ -51,6 +53,7 @@ export declare const listAuditRun: import("../../kernel/define.js").Implementati
         time: import("zod").ZodString;
         kind: import("zod").ZodEnum<{
             file: "file";
+            remote: "remote";
             session: "session";
             note: "note";
             commit: "commit";