windows-development-sandbox 1.7.0 → 1.10.0

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

@@ -0,0 +1,245 @@
+// The running sandbox as a whole: what it is doing (a live query), its window, and stopping it. Pure: schemas, labels
+// and the view; sandbox.run.ts does the work.
+import { z } from 'zod';
+import { action, ago, defineOperation, defineQuery, defineView, plural, } from '../../kernel/index.js';
+const ProjectSchema = z.object({
+    name: z.string().describe('The project'),
+    host: z.string().describe('Its folder on this PC'),
+    guest: z.string().describe('Its folder in the sandbox'),
+    mechanism: z.string().describe('How it got into the sandbox (launch, root, boot or share)'),
+    here: z.boolean().describe('The project of the current folder'),
+    setup: z.object({ phase: z.string(), message: z.string() }).describe('How far its setup is'),
+    databases: z.array(z.object({ database: z.string(), port: z.number(), state: z.string() })),
+    sessions: z.array(z.object({ id: z.string(), harness: z.string(), viewers: z.string(), started: z.string() })),
+    repoGuard: z.array(z.string()).describe('Repo guard findings in its folder'),
+});
+const StateSchema = z.object({
+    running: z.boolean().describe('A Windows Sandbox is running'),
+    phase: z.string().describe('What it is doing (ready, provisioning ...)'),
+    message: z.string().optional().describe('Its last message'),
+    headless: z.boolean().optional().describe('Its window is hidden'),
+    startedAt: z.number().nullable().describe('When it started (ms), if known'),
+    daemon: z.string().describe("The sandbox helper's answer"),
+    account: z.string().nullable().describe('The Claude login it uses'),
+    syncWatcher: z.boolean().describe('The background history sync runs'),
+});
+export const SandboxStatusSchema = z.object({
+    /** Present when the running sandbox is another user's. */
+    shared: z
+        .object({
+        line: z.string().describe('"Running, started by alice (shared with you)"'),
+        limited: z.boolean().describe('Not shared with you: nothing more is shown'),
+        startedBy: z.string().nullable().describe('Whose it is'),
+    })
+        .optional(),
+    sandbox: StateSchema,
+    here: z.object({ folder: z.string(), project: z.string().nullable(), guest: z.string().nullable() }),
+    roots: z.array(z.object({ host: z.string(), guest: z.string() })),
+    projects: z.array(ProjectSchema),
+    otherSessions: z.array(z.object({ id: z.string(), harness: z.string(), cwd: z.string() })),
+    repoGuard: z.object({ guarded: z.number(), findings: z.array(z.string()) }),
+});
+const MessageSchema = z.object({ message: z.string().describe('What happened') });
+/** "pong (2 session(s) running)" from the helper in the sandbox, in plain words. */
+export function helperText(answer) {
+    const sessions = /^pong \((\d+) session/.exec(answer);
+    if (!sessions)
+        return answer;
+    return 'responding, ' + plural(Number(sessions[1]), 'session') + ' running';
+}
+/** How long it has been up ("3 h"), or null. */
+function uptime(s) {
+    return s.running && s.startedAt ? ago(s.startedAt).replace(' ago', '') : null;
+}
+export const sandboxStatus = defineQuery({
+    id: 'sandbox.status',
+    title: 'Sandbox status',
+    summary: 'show what the sandbox is doing',
+    input: z.object({}),
+    output: SandboxStatusSchema,
+    live: { everyMs: 2500 },
+    cli: {
+        name: 'status',
+        group: 'Sessions',
+        json: true,
+        // The --json shape `sandbox status` has always printed.
+        shapeJson: (o) => {
+            if (o.shared?.limited)
+                return { sandbox: { running: true, shared: false, startedBy: o.shared.startedBy } };
+            const s = o.sandbox;
+            const borrowed = o.shared?.startedBy ? { startedBy: o.shared.startedBy, shared: true } : {};
+            return {
+                sandbox: {
+                    ...borrowed,
+                    running: s.running,
+                    phase: s.phase,
+                    message: s.message,
+                    headless: s.headless,
+                    uptime: uptime(s),
+                    daemon: s.daemon,
+                    account: s.account,
+                    syncWatcher: s.syncWatcher,
+                },
+                here: o.here,
+                roots: o.roots,
+                projects: o.projects,
+                otherSessions: o.otherSessions,
+                repoGuard: o.repoGuard,
+            };
+        },
+    },
+});
+export const showWindow = defineOperation({
+    id: 'sandbox.showWindow',
+    title: 'Show the window',
+    summary: 'show the sandbox window',
+    input: z.object({}),
+    output: MessageSchema,
+    text: (o) => o.message,
+    cli: { name: 'show', group: 'Sessions' },
+});
+export const hideWindow = defineOperation({
+    id: 'sandbox.hideWindow',
+    title: 'Hide the window',
+    summary: 'hide the sandbox window (it keeps running)',
+    input: z.object({}),
+    output: MessageSchema,
+    text: (o) => o.message,
+    cli: { name: 'hide', group: 'Sessions' },
+});
+export const stopSandbox = defineOperation({
+    id: 'sandbox.stop',
+    title: 'Stop the sandbox…',
+    summary: "shut the sandbox down (every project's sessions end)",
+    input: z.object({}),
+    output: z.object({ stopped: z.boolean().describe('It was asked to shut down'), message: z.string() }),
+    danger: true,
+    text: (o) => o.message,
+    cli: { name: 'stop', group: 'Agents', yes: "do not ask when other projects' sessions would end" },
+});
+const MECHANISM_TEXT = {
+    launch: 'started from here',
+    root: 'in a project root',
+    boot: 'mapped at start',
+};
+function projectItem(p) {
+    return {
+        id: 'project:' + p.name,
+        label: p.name,
+        hint: p.host + '  ->  ' + p.guest + '  (' + (MECHANISM_TEXT[p.mechanism] ?? 'wsb share') + ')',
+        marked: p.here,
+        details: [
+            'setup: ' + p.setup.phase + (p.setup.phase === 'ready' ? '' : ' - ' + p.setup.message),
+            ...(p.databases.length
+                ? ['databases: ' + p.databases.map((d) => d.database + ' :' + d.port + ' ' + d.state).join(', ')]
+                : []),
+            ...p.sessions.map((s) => 'session ' + s.id + '  ' + s.harness + '  ' + s.viewers + '  ' + ago(s.started)),
+            ...p.repoGuard.map((f) => 'guard: ' + f),
+        ],
+    };
+}
+function facts(o) {
+    const s = o.sandbox;
+    const sessions = o.projects.reduce((n, p) => n + p.sessions.length, 0) + o.otherSessions.length;
+    const fact = (id, label, value, extra = {}) => ({
+        id,
+        label,
+        value,
+        ...extra,
+    });
+    return [
+        ...(o.shared?.startedBy ? [fact('owner', 'Started by', o.shared.startedBy)] : []),
+        fact('running', 'Running', s.running ? 'yes' : 'no', { tone: s.running ? 'ok' : 'muted' }),
+        ...(s.running
+            ? [
+                fact('phase', 'Phase', s.phase, { tone: s.phase === 'ready' ? 'ok' : 'warn' }),
+                fact('message', 'Message', s.message || '-'),
+                fact('window', 'Window', s.headless ? 'hidden (sandbox show opens it)' : 'shown'),
+                fact('uptime', 'Uptime', uptime(s) ?? '-'),
+                fact('helper', 'Helper', s.daemon === '-' ? '-' : helperText(s.daemon)),
+                fact('sessions', 'Sessions', String(sessions)),
+            ]
+            : []),
+        fact('account', 'Account', s.account ?? 'none selected (sandbox account use)'),
+        fact('sync', 'Background sync', s.syncWatcher ? 'on' : 'off'),
+    ];
+}
+function projectsSection(o) {
+    const roots = o.roots.map((r) => ({
+        id: 'root:' + r.host,
+        label: 'root',
+        hint: r.host + '  ->  ' + r.guest + '  (every project in it opens without a restart)',
+    }));
+    const here = o.projects.some((p) => p.here);
+    return {
+        id: 'projects',
+        title: 'Projects',
+        items: [...o.projects.map(projectItem), ...roots],
+        notes: [
+            here
+                ? { text: '* = the project of this folder', tone: 'muted' }
+                : { text: o.here.folder + ' is not in this sandbox (start it here: sandbox claude)', tone: 'muted' },
+        ],
+    };
+}
+function guardSection(o) {
+    const findings = o.repoGuard.findings;
+    return {
+        id: 'guard',
+        title: 'Repo guard',
+        summary: o.repoGuard.guarded +
+            ' folder(s) guarded; ' +
+            (findings.length ? findings.length + ' change(s) neutralised:' : 'nothing from the sandbox needed neutralising'),
+        items: findings.slice(-10).map((f, i) => ({ id: 'guard:' + i, label: f, tone: 'warn' })),
+    };
+}
+/** The status page: the facts, the window and stop actions, the projects, and the repo guard. */
+export function sandboxPage(o) {
+    const notice = o.shared
+        ? {
+            text: o.shared.line + (o.shared.limited ? '' : '. Its window is on their desktop; use its agents here.'),
+            tone: 'accent',
+        }
+        : undefined;
+    if (o.shared?.limited)
+        return { title: 'Sandbox', notice, sections: [] };
+    const running = o.sandbox.running;
+    const status = {
+        id: 'status',
+        facts: facts(o),
+        actions: running
+            ? [
+                action(showWindow, {}, { key: 'w', verb: 'show', importance: 3 }),
+                action(hideWindow, {}, { key: 'h', verb: 'hide', importance: 3 }),
+                action(stopSandbox, {}, { key: 'x', verb: 'stop', importance: 1 }),
+            ]
+            : [],
+    };
+    const others = {
+        id: 'other-sessions',
+        title: 'Other sessions',
+        items: o.otherSessions.map((s) => ({
+            id: 'session:' + s.id,
+            label: 'session ' + s.id,
+            hint: s.harness + '  ' + s.cwd,
+        })),
+    };
+    return {
+        title: 'Sandbox',
+        notice,
+        sections: [
+            status,
+            ...(running ? [projectsSection(o)] : []),
+            ...(others.items?.length ? [others] : []),
+            guardSection(o),
+        ],
+    };
+}
+export const sandboxView = defineView({
+    id: 'sandbox',
+    title: 'Sandbox',
+    summary: 'What the sandbox is doing, its window, and stopping it.',
+    queries: { status: sandboxStatus },
+    operations: [showWindow, hideWindow, stopSandbox],
+    build: ({ status }) => sandboxPage(status),
+});

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

@@ -0,0 +1,72 @@
+export declare const sandboxStatusRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    shared: import("zod").ZodOptional<import("zod").ZodObject<{
+        line: import("zod").ZodString;
+        limited: import("zod").ZodBoolean;
+        startedBy: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    sandbox: import("zod").ZodObject<{
+        running: import("zod").ZodBoolean;
+        phase: import("zod").ZodString;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        headless: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        startedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+        daemon: import("zod").ZodString;
+        account: import("zod").ZodNullable<import("zod").ZodString>;
+        syncWatcher: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>;
+    here: import("zod").ZodObject<{
+        folder: import("zod").ZodString;
+        project: import("zod").ZodNullable<import("zod").ZodString>;
+        guest: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    roots: import("zod").ZodArray<import("zod").ZodObject<{
+        host: import("zod").ZodString;
+        guest: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    projects: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        host: import("zod").ZodString;
+        guest: import("zod").ZodString;
+        mechanism: import("zod").ZodString;
+        here: import("zod").ZodBoolean;
+        setup: import("zod").ZodObject<{
+            phase: import("zod").ZodString;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        databases: import("zod").ZodArray<import("zod").ZodObject<{
+            database: import("zod").ZodString;
+            port: import("zod").ZodNumber;
+            state: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        sessions: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            harness: import("zod").ZodString;
+            viewers: import("zod").ZodString;
+            started: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        repoGuard: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    otherSessions: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        harness: import("zod").ZodString;
+        cwd: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    repoGuard: import("zod").ZodObject<{
+        guarded: import("zod").ZodNumber;
+        findings: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, "sandbox.status">, import("../../../cli/commands/context.js").Context>;
+export declare const showWindowRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sandbox.showWindow">, import("../../../cli/commands/context.js").Context>;
+export declare const hideWindowRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sandbox.hideWindow">, import("../../../cli/commands/context.js").Context>;
+/**
+ * Stopping ends every project's sessions: it says which, and the sessions of other projects need a yes (also on the
+ * command line, where --yes gives it; a script without it fails rather than end them by accident).
+ */
+export declare const stopSandboxRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    stopped: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "sandbox.stop">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,98 @@
+// The sandbox feature's work: its status (from the services, as this user may see it), its window and stopping it.
+// Talks only through `io`; another user's sandbox follows the sharing rules (cli/commands/shared-use.ts).
+import path from 'node:path';
+import { safeText } from '../../../core/util/index.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { runningOwner } from '../../../host/sharing/index.js';
+import { requireOnPc, requireRunning } from '../../../cli/commands/context.js';
+import { hereDir } from '../../../cli/commands/projects/here.js';
+import { lookAtSandbox, useSharedSandbox } from '../../../cli/commands/shared-use.js';
+import { SandboxService } from '../../../cli/services/index.js';
+import { implement, typedConfirm } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { hideWindow, sandboxStatus, showWindow, stopSandbox } from './sandbox.def.js';
+/** Another user's sandbox that is not shared: whose it is, and nothing else. */
+function limitedStatus(view, folder) {
+    const owner = view.owner;
+    return {
+        shared: { line: view.line ?? '', limited: true, startedBy: owner?.kind === 'other' ? owner.user : null },
+        sandbox: {
+            running: true,
+            phase: 'unknown',
+            startedAt: null,
+            daemon: '-',
+            account: null,
+            syncWatcher: false,
+        },
+        here: { folder, project: null, guest: null },
+        roots: [],
+        projects: [],
+        otherSessions: [],
+        repoGuard: { guarded: 0, findings: [] },
+    };
+}
+export const sandboxStatusRun = implement(sandboxStatus, async (asked) => {
+    const view = lookAtSandbox(asked);
+    if (view.limited)
+        return limitedStatus(view, hereDir(asked));
+    const report = await new SandboxService(view.ctx).status();
+    return {
+        ...(view.line ? { shared: { line: view.line, limited: false, startedBy: view.ctx.borrowed?.user ?? null } } : {}),
+        ...report,
+        sandbox: { ...report.sandbox, daemon: safeText(report.sandbox.daemon) },
+    };
+});
+export const showWindowRun = implement(showWindow, async (ctx, _input, io) => {
+    requireOnPc('show');
+    requireRunning();
+    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'show the window', window: true }, typedConfirm(io));
+    new SandboxService(ctx).showWindow();
+    return { message: 'Sandbox window shown.' };
+});
+export const hideWindowRun = implement(hideWindow, async (ctx, _input, io) => {
+    requireOnPc('hide');
+    requireRunning();
+    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'hide the window', window: true }, typedConfirm(io));
+    io.progress('Hiding the window');
+    await new SandboxService(ctx).hideWindow();
+    return { message: 'Sandbox window hidden. Bring it back with: sbx-show' };
+});
+/**
+ * Stopping ends every project's sessions: it says which, and the sessions of other projects need a yes (also on the
+ * command line, where --yes gives it; a script without it fails rather than end them by accident).
+ */
+export const stopSandboxRun = implement(stopSandbox, async (asked, _input, io) => {
+    requireOnPc('stop');
+    if (!new SandboxService(asked).isRunning())
+        return { stopped: false, message: 'No Windows Sandbox is running.' };
+    // Another user's sandbox: only when shared, and only after typing their name (--yes in scripts).
+    const ctx = runningOwner().kind === 'mine'
+        ? asked
+        : await useSharedSandbox(asked, (shared) => ({ kind: 'stop', sessions: new SandboxChannel(shared.dataPath).currentSessions().length }), typedConfirm(io));
+    const service = new SandboxService(ctx);
+    const { sandbox, running, others } = service.stopPlan();
+    if (running.length)
+        io.log('Stopping ends ' +
+            running.length +
+            ' session(s): ' +
+            running
+                .map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd)))
+                .join(', ') +
+            '.');
+    const yes = await io.confirm({
+        title: others.length ? 'Stop the whole sandbox?' : 'Stop the sandbox?',
+        lines: others.length ? [others.length + ' of them belong to other projects.'] : [],
+        yes: 'Stop',
+        danger: true,
+        implied: others.length === 0,
+        noTerminal: {
+            message: others.length + ' of these sessions belong to other projects, so the sandbox was not stopped.',
+            fix: 'Stop it anyway with: sandbox stop --yes',
+        },
+    });
+    if (!yes)
+        cancelled();
+    io.progress('Asking the sandbox to shut down');
+    await service.shutdown(sandbox);
+    return { stopped: true, message: 'Sandbox is shutting down; history and claude-mem sync back when it closes.' };
+});

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

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

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

@@ -0,0 +1,3 @@
+// The sessions feature: the list (live) and restarting the agents.
+export * from './sessions.def.js';
+export * from './sessions.run.js';

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

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+/** A session as every surface may see it: never its attach address or token. */
+export declare const SessionRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    launchId: z.ZodString;
+    harness: z.ZodString;
+    cwd: z.ZodString;
+    project: z.ZodOptional<z.ZodString>;
+    phase: z.ZodEnum<{
+        failed: "failed";
+        starting: "starting";
+        running: "running";
+        exited: "exited";
+    }>;
+    message: z.ZodString;
+    updatedAt: z.ZodString;
+    startedAt: z.ZodString;
+    conversation: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    projectName: z.ZodOptional<z.ZodString>;
+    here: z.ZodOptional<z.ZodBoolean>;
+    viewers: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        viewers: z.ZodNumber;
+        remote: z.ZodNumber;
+    }, z.core.$strip>>>;
+    canOpen: z.ZodBoolean;
+}, z.core.$strip>;
+export type SessionRow = z.output<typeof SessionRowSchema>;
+export declare const SessionsListSchema: z.ZodObject<{
+    sandboxRunning: z.ZodBoolean;
+    defaultAgent: z.ZodString;
+    wide: z.ZodBoolean;
+    owner: z.ZodOptional<z.ZodString>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        launchId: z.ZodString;
+        harness: z.ZodString;
+        cwd: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        phase: z.ZodEnum<{
+            failed: "failed";
+            starting: "starting";
+            running: "running";
+            exited: "exited";
+        }>;
+        message: z.ZodString;
+        updatedAt: z.ZodString;
+        startedAt: z.ZodString;
+        conversation: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        projectName: z.ZodOptional<z.ZodString>;
+        here: z.ZodOptional<z.ZodBoolean>;
+        viewers: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            viewers: z.ZodNumber;
+            remote: z.ZodNumber;
+        }, z.core.$strip>>>;
+        canOpen: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SessionsList = z.output<typeof SessionsListSchema>;
+/** "1 here, 0 in sandbox" for a session's viewers. */
+export declare function viewerText(v: SessionRow['viewers']): string;
+/** This folder's project first, newest first within each group. */
+export declare function orderedSessions(list: readonly SessionRow[]): SessionRow[];
+export declare const listSessions: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    wide: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    sandboxRunning: z.ZodBoolean;
+    defaultAgent: z.ZodString;
+    wide: z.ZodBoolean;
+    owner: z.ZodOptional<z.ZodString>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        launchId: z.ZodString;
+        harness: z.ZodString;
+        cwd: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+        phase: z.ZodEnum<{
+            failed: "failed";
+            starting: "starting";
+            running: "running";
+            exited: "exited";
+        }>;
+        message: z.ZodString;
+        updatedAt: z.ZodString;
+        startedAt: z.ZodString;
+        conversation: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        projectName: z.ZodOptional<z.ZodString>;
+        here: z.ZodOptional<z.ZodBoolean>;
+        viewers: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            viewers: z.ZodNumber;
+            remote: z.ZodNumber;
+        }, z.core.$strip>>>;
+        canOpen: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "sessions.list">;
+export declare const restartSessions: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    harness: z.ZodOptional<z.ZodString>;
+    all: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "sessions.restart">;
+/** The sessions page: one list (a table on the command line), this folder's project first. */
+export declare function sessionsPage(o: SessionsList): Page;
+export declare const sessionsView: import("../../kernel/define.js").ViewDef<{
+    sessions: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+        wide: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        sandboxRunning: z.ZodBoolean;
+        defaultAgent: z.ZodString;
+        wide: z.ZodBoolean;
+        owner: z.ZodOptional<z.ZodString>;
+        sessions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            launchId: z.ZodString;
+            harness: z.ZodString;
+            cwd: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+            phase: z.ZodEnum<{
+                failed: "failed";
+                starting: "starting";
+                running: "running";
+                exited: "exited";
+            }>;
+            message: z.ZodString;
+            updatedAt: z.ZodString;
+            startedAt: z.ZodString;
+            conversation: z.ZodOptional<z.ZodString>;
+            exitCode: z.ZodOptional<z.ZodNumber>;
+            projectName: z.ZodOptional<z.ZodString>;
+            here: z.ZodOptional<z.ZodBoolean>;
+            viewers: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                viewers: z.ZodNumber;
+                remote: z.ZodNumber;
+            }, z.core.$strip>>>;
+            canOpen: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "sessions.list">;
+}, Record<string, never>, "sessions">;