windows-development-sandbox 1.10.0 → 1.11.4

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

@@ -0,0 +1,77 @@
+// The engine feature's work: what each engine can do and whether this PC can run it (engineReports, which runs a few
+// Windows programs, so it is read on purpose and never live). Nothing is run or changed for the check's fixes.
+import { fail, safeText } from '../../../core/util/index.js';
+import { engineReports, lookForLeftovers, stopLeftovers } from '../../../host/engines/index.js';
+import { implement } from '../../context.js';
+import { cancelled, plural } from '../../kernel/index.js';
+import { checkEngine, cleanEngine, engineLeftovers, engineStatus, } from './engine.def.js';
+/** The report as the definitions describe it (the host's arrays are readonly; the output is plain data). */
+function reportRow(r) {
+    return {
+        id: r.id,
+        inUse: r.inUse,
+        capabilities: { ...r.capabilities },
+        check: { available: r.check.available, reasons: [...r.check.reasons], fixes: [...r.check.fixes] },
+    };
+}
+export const engineStatusRun = implement(engineStatus, async (ctx) => {
+    const reports = await engineReports(ctx.loaded.config);
+    const using = reports.find((r) => r.inUse);
+    return {
+        engine: using?.id ?? ctx.loaded.config.sandbox.engine,
+        engines: reports.map(reportRow),
+    };
+});
+export const checkEngineRun = implement(checkEngine, async (ctx, input) => {
+    const report = (await engineReports(ctx.loaded.config)).find((r) => r.id === input.engine);
+    if (!report)
+        return fail('Unknown engine: ' + input.engine, 'Use windows-sandbox or hcs.');
+    return reportRow(report);
+});
+export const engineLeftoversRun = implement(engineLeftovers, (ctx) => {
+    const look = lookForLeftovers(ctx.loaded.config.storage.root);
+    if (!look.available)
+        return { available: false, message: look.reason, systems: [] };
+    const systems = look.systems.map((s) => ({
+        id: s.id,
+        kind: safeText(s.kind),
+        state: safeText(s.state),
+        since: s.since,
+    }));
+    return {
+        available: true,
+        message: systems.length
+            ? plural(systems.length, 'HCS system') + ' of ours left running.'
+            : 'No HCS system of ours is running.',
+        systems,
+    };
+});
+export const cleanEngineRun = implement(cleanEngine, async (ctx, _input, io) => {
+    const root = ctx.loaded.config.storage.root;
+    const look = lookForLeftovers(root);
+    if (!look.available)
+        return { available: false, stopped: 0, failed: 0, message: look.reason + ' Nothing to clean.' };
+    if (!look.systems.length)
+        return { available: true, stopped: 0, failed: 0, message: 'No HCS system of ours is running. Nothing to clean.' };
+    const yes = await io.confirm({
+        title: 'Stop ' + plural(look.systems.length, 'HCS system') + '?',
+        lines: [
+            ...look.systems.map((s) => s.id + '  (' + safeText(s.kind) + ', ' + safeText(s.state) + ')'),
+            'A sandbox of yours that is running on purpose is listed too: stopping it ends its sessions.',
+            "No file is deleted, and other programs and other Windows users' sandboxes are not touched.",
+        ],
+        yes: 'Stop them',
+        danger: true,
+    });
+    if (!yes)
+        cancelled();
+    io.progress('Stopping HCS systems');
+    const results = stopLeftovers(root, look.systems.map((s) => s.id));
+    for (const r of results)
+        io.log(r.stopped ? 'Stopped ' + r.id : 'Could not stop ' + r.id + ': ' + safeText(r.problem ?? ''), r.stopped ? 'ok' : 'danger');
+    const stopped = results.filter((r) => r.stopped).length;
+    const failed = results.length - stopped;
+    if (failed)
+        fail(plural(failed, 'HCS system') + ' could not be stopped.', 'Run it again from an administrator terminal: sandbox engine clean');
+    return { available: true, stopped, failed, message: 'Stopped ' + plural(stopped, 'HCS system') + '.' };
+});

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

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

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

@@ -0,0 +1,4 @@
+// The engine feature: the engine in use and what each engine can do, with each engine's check (sandbox engine and
+// sandbox engine check). The definitions are pure; engine.run.ts does the work.
+export * from './engine.def.js';
+export * from './engine.run.js';

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+/** Folders show at most this many entries (a folder with more says so). */
+export declare const MAX_ENTRIES = 2000;
+declare const EntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        dir: "dir";
+    }>;
+}, z.core.$strip>;
+export type FolderEntry = z.output<typeof EntrySchema>;
+export declare const FolderListingSchema: z.ZodObject<{
+    path: z.ZodString;
+    parent: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            dir: "dir";
+        }>;
+    }, z.core.$strip>>;
+    truncated: z.ZodBoolean;
+    places: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FolderListing = z.output<typeof FolderListingSchema>;
+export declare const browseFolder: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    parent: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            dir: "dir";
+        }>;
+    }, z.core.$strip>>;
+    truncated: z.ZodBoolean;
+    places: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "files.browse">;
+export {};

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

@@ -0,0 +1,38 @@
+// Picking a folder or a file of this PC: what is in a folder, and where to start (the drives, this folder's project,
+// the data folder). The browser cannot see full paths, so the web's folder picker reads this. Pure: schemas only.
+import { z } from 'zod';
+import { defineQuery } from '../../kernel/index.js';
+/** Folders show at most this many entries (a folder with more says so). */
+export const MAX_ENTRIES = 2000;
+const EntrySchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    kind: z.enum(['dir', 'file']),
+});
+export const FolderListingSchema = z.object({
+    /** The folder listed ('' when only the places are listed). */
+    path: z.string(),
+    /** The folder above it, or null at a drive (or with no folder). */
+    parent: z.string().nullable(),
+    entries: z.array(EntrySchema),
+    /** More entries than MAX_ENTRIES: the rest are left out. */
+    truncated: z.boolean(),
+    /** Where to start: the drives and a few folders that matter here. */
+    places: z.array(z.object({ label: z.string(), path: z.string() })),
+});
+export const browseFolder = defineQuery({
+    id: 'files.browse',
+    title: 'Browse folders',
+    summary: 'list what is in a folder of this PC, to pick a folder or a file',
+    input: z.object({
+        path: z.string().max(1024).optional().describe('The folder (none: only the places to start from)'),
+        files: z.boolean().default(false).describe('List files too, not only folders'),
+    }),
+    output: FolderListingSchema,
+    surfaces: {
+        except: {
+            cli: 'a path is typed on the command line',
+            menu: 'the menu asks for a path as text and checks it',
+        },
+    },
+});

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

@@ -0,0 +1,20 @@
+export declare const browseFolderRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    path: import("zod").ZodOptional<import("zod").ZodString>;
+    files: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    parent: import("zod").ZodNullable<import("zod").ZodString>;
+    entries: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        path: import("zod").ZodString;
+        kind: import("zod").ZodEnum<{
+            file: "file";
+            dir: "dir";
+        }>;
+    }, import("zod/v4/core").$strip>>;
+    truncated: import("zod").ZodBoolean;
+    places: import("zod").ZodArray<import("zod").ZodObject<{
+        label: import("zod").ZodString;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "files.browse">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,59 @@
+// The folder picker's listing: names in one folder (folders first), read once with a cap, and the places to start
+// from. Only names and paths of this PC go to the signed-in browser of this PC's user; nothing is opened or followed.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fail } from '../../../core/util/index.js';
+import { hereDir } from '../../../cli/commands/projects/here.js';
+import { implement } from '../../context.js';
+import { browseFolder, MAX_ENTRIES } from './files.def.js';
+const DRIVES = 'CDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+function places(ctx) {
+    const drives = DRIVES.filter((d) => {
+        try {
+            return fs.statSync(d + ':\\').isDirectory();
+        }
+        catch {
+            return false; // no such drive, or an empty card reader
+        }
+    }).map((d) => ({ label: d + ':', path: d + ':\\' }));
+    const folders = [
+        { label: "This folder's project", path: hereDir(ctx) },
+        { label: 'Data folder', path: ctx.storageRoot },
+    ].filter((p) => p.path && fs.existsSync(p.path));
+    return [...folders, ...drives];
+}
+function listing(folder, files) {
+    let dirents;
+    try {
+        dirents = fs.readdirSync(folder, { withFileTypes: true });
+    }
+    catch {
+        return fail('Cannot open ' + folder + '.', 'Pick another folder, or check that you may read this one.');
+    }
+    const entries = [];
+    for (const d of dirents) {
+        // A link to a folder is offered as a folder (it is still a path you can type); system folders like $Recycle.Bin
+        // are left out.
+        const dir = d.isDirectory() || d.isSymbolicLink();
+        if (d.name.startsWith('$') || (!dir && !files))
+            continue;
+        entries.push({ name: d.name, path: path.join(folder, d.name), kind: dir ? 'dir' : 'file' });
+    }
+    entries.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }) : a.kind === 'dir' ? -1 : 1);
+    return { entries: entries.slice(0, MAX_ENTRIES), truncated: entries.length > MAX_ENTRIES };
+}
+export const browseFolderRun = implement(browseFolder, (ctx, input) => {
+    const start = places(ctx);
+    if (!input.path)
+        return { path: '', parent: null, entries: [], truncated: false, places: start };
+    if (!path.isAbsolute(input.path) || input.path.includes('\0'))
+        fail('"' + input.path + '" is not a full path.', 'Use a path like C:\\Projects.');
+    const folder = path.resolve(input.path);
+    const parent = path.dirname(folder);
+    return {
+        path: folder,
+        parent: parent === folder ? null : parent,
+        ...listing(folder, input.files),
+        places: start,
+    };
+});

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

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

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

@@ -0,0 +1,3 @@
+// The files feature: listing a folder of this PC for the folder picker.
+export * from './files.def.js';
+export * from './files.run.js';

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+/** Where GitHub makes a fine-grained token. */
+export declare const NEW_TOKEN_URL = "https://github.com/settings/personal-access-tokens/new";
+/** The steps to make a token for sandboxes (shown before asking for it). */
+export declare const GITHUB_STEPS: readonly string[];
+/** What everyone who shares a token must know: on every surface. */
+export declare const GITHUB_WARNINGS: readonly string[];
+export declare const GithubStatusSchema: z.ZodObject<{
+    shareToken: z.ZodBoolean;
+    gitAccess: z.ZodEnum<{
+        readonly: "readonly";
+        none: "none";
+        full: "full";
+    }>;
+    token: z.ZodEnum<{
+        none: "none";
+        saved: "saved";
+        unreadable: "unreadable";
+    }>;
+    kind: z.ZodNullable<z.ZodEnum<{
+        "fine-grained": "fine-grained";
+        classic: "classic";
+    }>>;
+    savedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type GithubStatus = z.output<typeof GithubStatusSchema>;
+export declare const githubStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+    shareToken: z.ZodBoolean;
+    gitAccess: z.ZodEnum<{
+        readonly: "readonly";
+        none: "none";
+        full: "full";
+    }>;
+    token: z.ZodEnum<{
+        none: "none";
+        saved: "saved";
+        unreadable: "unreadable";
+    }>;
+    kind: z.ZodNullable<z.ZodEnum<{
+        "fine-grained": "fine-grained";
+        classic: "classic";
+    }>>;
+    savedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, "github.status">;
+export declare const githubLogin: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "github.login">;
+export declare const githubLogout: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+    deleted: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>, "github.logout">;
+/** The Settings row of the menu (label, hint, description), from the status. Pure. */
+export declare function githubTokenRowOf(s: GithubStatus): {
+    label: string;
+    hint: string;
+    description: string;
+};
+/** The status page: the facts, the next step (command line only), the warnings and the token actions. */
+export declare function githubPage(s: GithubStatus): Page;
+export declare const githubView: import("../../kernel/define.js").ViewDef<{
+    status: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        shareToken: z.ZodBoolean;
+        gitAccess: z.ZodEnum<{
+            readonly: "readonly";
+            none: "none";
+            full: "full";
+        }>;
+        token: z.ZodEnum<{
+            none: "none";
+            saved: "saved";
+            unreadable: "unreadable";
+        }>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            "fine-grained": "fine-grained";
+            classic: "classic";
+        }>>;
+        savedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, "github.status">;
+}, Record<string, never>, "github">;

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

@@ -0,0 +1,142 @@
+// The GitHub token for sandboxes: whether sharing is on, whether a token is saved (its kind and date, never its value),
+// and saving or deleting it. Pure: schemas, labels and the view; github.run.ts does the work. The token itself is never
+// an input or an output.
+import { z } from 'zod';
+import { action, defineOperation, defineQuery, defineView, } from '../../kernel/index.js';
+/** Where GitHub makes a fine-grained token. */
+export const NEW_TOKEN_URL = 'https://github.com/settings/personal-access-tokens/new';
+/** The steps to make a token for sandboxes (shown before asking for it). */
+export const GITHUB_STEPS = [
+    'Open ' + NEW_TOKEN_URL + ' (a fine-grained personal access token).',
+    'Under "Repository access" choose "Only select repositories" and pick only the ones the agent should reach.',
+    'Give only the permissions it needs, for example Contents (read and write), Pull requests (read and write) and Actions (read).',
+    'Set an expiry date, then generate the token and copy it.',
+];
+/** What everyone who shares a token must know: on every surface. */
+export const GITHUB_WARNINGS = [
+    'The agent in the sandbox can read the token and use it for everything it allows: limit it to some repositories and permissions.',
+    'It is handed over only with github.shareToken on and git access "full". Revoke it on GitHub whenever you like.',
+];
+const TokenStateSchema = z
+    .enum(['none', 'saved', 'unreadable'])
+    .describe('Whether a token is saved and can be opened by you');
+export const GithubStatusSchema = z.object({
+    shareToken: z.boolean().describe('Sandboxes get the token (setting github.shareToken)'),
+    gitAccess: z.enum(['full', 'readonly', 'none']).describe('Git access in your settings (provisioning.git.access)'),
+    token: TokenStateSchema,
+    kind: z.enum(['fine-grained', 'classic']).nullable().describe('What kind of token is saved (never the token)'),
+    savedAt: z.string().nullable().describe('When the token was saved (the date and time, never the token)'),
+});
+export const githubStatus = defineQuery({
+    id: 'github.status',
+    title: 'GitHub',
+    summary: 'whether sandboxes get your GitHub token, and whether one is saved (never the token)',
+    input: z.object({}).strict(),
+    output: GithubStatusSchema,
+    cli: { name: 'github', action: 'status', json: true },
+});
+export const githubLogin = defineOperation({
+    id: 'github.login',
+    title: 'Save the GitHub token…',
+    summary: 'save a GitHub token for sandboxes (typed hidden, kept encrypted, never printed)',
+    input: z.object({}).strict(),
+    output: z.object({ message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    cli: { name: 'github', action: 'login' },
+});
+export const githubLogout = defineOperation({
+    id: 'github.logout',
+    title: 'Delete the GitHub token',
+    summary: 'delete the saved GitHub token',
+    input: z.object({}).strict(),
+    output: z.object({
+        deleted: z.boolean().describe('A token was saved and is gone'),
+        message: z.string().describe('What happened'),
+    }),
+    danger: true,
+    text: (o) => o.message,
+    cli: { name: 'github', action: 'logout' },
+});
+const TOKEN_TEXT = {
+    none: 'not saved',
+    saved: 'saved (encrypted)',
+    unreadable: 'cannot be read',
+};
+const TOKEN_TONE = {
+    none: 'warn',
+    saved: 'ok',
+    unreadable: 'danger',
+};
+const KIND_TEXT = {
+    'fine-grained': 'fine-grained',
+    classic: 'classic (reaches every repository you can: a fine-grained token is safer)',
+};
+/** The Settings row of the menu (label, hint, description), from the status. Pure. */
+export function githubTokenRowOf(s) {
+    return {
+        label: 'Set GitHub token…',
+        hint: s.token === 'saved' ? 'saved' : s.token === 'unreadable' ? 'cannot be read' : 'not saved',
+        description: 'A GitHub token you made for sandboxes (best a fine-grained one, limited to some repositories and permissions). Typed hidden, kept encrypted for your Windows user, never shown. Sandboxes get it only with github.shareToken on. ' +
+            GITHUB_WARNINGS.join(' '),
+    };
+}
+/** The status page: the facts, the next step (command line only), the warnings and the token actions. */
+export function githubPage(s) {
+    const savedDate = s.savedAt ? '  ' + s.savedAt.slice(0, 10) : '';
+    const facts = [
+        s.shareToken
+            ? { id: 'share', label: 'Share with sandboxes', value: 'on', tone: 'ok' }
+            : {
+                id: 'share',
+                label: 'Share with sandboxes',
+                value: 'off  (turn on: sandbox config set github.shareToken true)',
+            },
+        s.gitAccess === 'full'
+            ? { id: 'gitAccess', label: 'Git access', value: 'full' }
+            : {
+                id: 'gitAccess',
+                label: 'Git access',
+                value: s.gitAccess + '  (the token is only handed over with "full")',
+                tone: 'warn',
+            },
+        { id: 'token', label: 'Token', value: TOKEN_TEXT[s.token] + savedDate, tone: TOKEN_TONE[s.token] },
+        ...(s.kind
+            ? [
+                {
+                    id: 'kind',
+                    label: 'Kind',
+                    value: KIND_TEXT[s.kind],
+                    ...(s.kind === 'classic' ? { tone: 'warn' } : {}),
+                },
+            ]
+            : []),
+    ];
+    const notes = [
+        ...(s.token === 'none'
+            ? [{ text: 'Next: sandbox github login', tone: 'muted', only: 'cli' }]
+            : []),
+        ...(s.token === 'unreadable'
+            ? [
+                {
+                    text: 'Only the Windows user that saved it can read it. Save it again: sandbox github login',
+                    tone: 'muted',
+                },
+            ]
+            : []),
+        ...GITHUB_WARNINGS.map((text) => ({ text, tone: 'muted' })),
+    ];
+    const actions = [
+        action(githubLogin, {}, { key: 'g', verb: 'save token' }),
+        ...(s.token !== 'none' ? [action(githubLogout, {}, { key: 'x', verb: 'delete token' })] : []),
+    ];
+    const section = { id: 'github', facts, notes, actions };
+    return { title: 'GitHub', sections: [section] };
+}
+export const githubView = defineView({
+    id: 'github',
+    title: 'GitHub',
+    summary: 'A GitHub token for sandboxes: whether they get it, and the saved token.',
+    queries: { status: githubStatus },
+    operations: [githubLogin, githubLogout],
+    build: ({ status }) => githubPage(status),
+});

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

@@ -0,0 +1,36 @@
+import { GithubToken } from '../../../host/github/index.js';
+import { type OperationIO } from '../../kernel/index.js';
+/** Asks for the token (one hidden question) and saves it. The validator answers with fixed texts only. */
+export declare function saveGithubTokenFlow(io: OperationIO, store: GithubToken): Promise<{
+    message: string;
+}>;
+/** Deletes the saved token after asking (the CLI's typed logout is the answer). */
+export declare function deleteGithubTokenFlow(io: OperationIO, store: GithubToken): Promise<{
+    deleted: boolean;
+    message: string;
+}>;
+export declare const githubStatusRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    shareToken: import("zod").ZodBoolean;
+    gitAccess: import("zod").ZodEnum<{
+        readonly: "readonly";
+        none: "none";
+        full: "full";
+    }>;
+    token: import("zod").ZodEnum<{
+        none: "none";
+        saved: "saved";
+        unreadable: "unreadable";
+    }>;
+    kind: import("zod").ZodNullable<import("zod").ZodEnum<{
+        "fine-grained": "fine-grained";
+        classic: "classic";
+    }>>;
+    savedAt: import("zod").ZodNullable<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "github.status">, import("../../../cli/commands/context.js").Context>;
+export declare const githubLoginRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "github.login">, import("../../../cli/commands/context.js").Context>;
+export declare const githubLogoutRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    deleted: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "github.logout">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,59 @@
+// The GitHub feature's work: its status, saving the token through io.secret (kept only for the save, never returned,
+// logged or shown), and deleting it after a confirmation. The flows take the store, so the self-test runs them with a
+// store of its own.
+import { requireOnPc } from '../../../cli/commands/context.js';
+import { GithubToken } from '../../../host/github/index.js';
+import { githubTokenProblem } from '../../../shared/github/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { GITHUB_STEPS, GITHUB_WARNINGS, githubLogin, githubLogout, githubStatus } from './github.def.js';
+/** Asks for the token (one hidden question) and saves it. The validator answers with fixed texts only. */
+export async function saveGithubTokenFlow(io, store) {
+    io.log('Make a GitHub token only for sandboxes:');
+    GITHUB_STEPS.forEach((s, i) => io.log('  ' + (i + 1) + '. ' + s));
+    io.log('What you type is not shown. It is kept encrypted for your Windows user and never printed.', 'muted');
+    const token = await io.secret({
+        title: 'GitHub token',
+        validate: (v) => githubTokenProblem(v.trim())?.message ?? true,
+    });
+    if (token === undefined)
+        cancelled();
+    const kind = store.save(token.trim());
+    GITHUB_WARNINGS.forEach((w) => io.log(w, 'warn'));
+    if (kind === 'classic')
+        io.log('This is a classic token: it reaches every repository you can. A fine-grained one is safer.', 'warn');
+    return { message: 'Saved. Sandboxes get it once you turn it on: sandbox config set github.shareToken true' };
+}
+/** Deletes the saved token after asking (the CLI's typed logout is the answer). */
+export async function deleteGithubTokenFlow(io, store) {
+    if (store.state() === 'none')
+        return { deleted: false, message: 'No GitHub token was saved.' };
+    const yes = await io.confirm({ title: 'Delete the saved GitHub token?', yes: 'Delete', danger: true, implied: true });
+    if (!yes)
+        cancelled();
+    store.remove();
+    return {
+        deleted: true,
+        message: 'The saved GitHub token is deleted. Revoke it on GitHub too if you no longer use it.',
+    };
+}
+export const githubStatusRun = implement(githubStatus, async (ctx) => {
+    const { config } = ctx.loaded;
+    const store = new GithubToken(ctx.storageRoot);
+    const token = store.state();
+    return {
+        shareToken: config.github.shareToken,
+        gitAccess: config.provisioning.git.access,
+        token,
+        kind: token === 'none' ? null : store.kind(),
+        savedAt: token === 'none' ? null : store.savedAt(),
+    };
+});
+export const githubLoginRun = implement(githubLogin, async (ctx, _input, io) => {
+    requireOnPc('github login');
+    return saveGithubTokenFlow(io, new GithubToken(ctx.storageRoot));
+});
+export const githubLogoutRun = implement(githubLogout, async (ctx, _input, io) => {
+    requireOnPc('github logout');
+    return deleteGithubTokenFlow(io, new GithubToken(ctx.storageRoot));
+});

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

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

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

@@ -0,0 +1,3 @@
+// The GitHub feature: whether sandboxes get your token, saving and deleting it.
+export * from './github.def.js';
+export * from './github.run.js';