windows-development-sandbox 1.4.1 → 1.5.0

package/dist/cli/commands/repair/index.js

@@ -3,49 +3,35 @@
 // sandbox is running.
 import path from 'node:path';
 import _ from 'lodash';
-import { DEFAULTS, loadConfig, userDir } from '../../../core/config.js';
-import { errMsg, expandPath, UserError } from '../../../core/util.js';
-import { isSandboxRunning } from '../../../host/platform.js';
-import { createContext, printJson, table } from '../context.js';
-import { CHECKS } from './checks.js';
-const LABEL = { ok: 'OK', fixed: 'FIXED', 'needs-you': 'NEEDS YOU', warn: 'WARNING', skipped: 'SKIPPED' };
-/** Runs every check in order; a check that throws is reported, never stops the rest. */
-export const runChecks = (env, checks = CHECKS) => checks.map((check) => {
-    try {
-        return { name: check.name, ...check.run(env) };
-    }
-    catch (e) {
-        const fix = e instanceof UserError && e.fix ? ' ' + e.fix : '';
-        return { name: check.name, status: 'needs-you', detail: 'check failed: ' + errMsg(e) + fix };
-    }
-});
-export const repair = (ctx, configError = null) => {
-    const env = { ctx, running: isSandboxRunning(), dataPath: ctx.dataPath, storageRoot: ctx.storageRoot, toolsDir: path.join(ctx.dataPath, 'tools'), configError };
-    // Re-check the config file even when the context loaded (it may have been edited since, or come from --config).
-    if (!env.configError) {
-        try {
-            loadConfig(ctx.options.config);
-        }
-        catch (e) {
-            if (e instanceof UserError)
-                env.configError = e;
-            else
-                throw e;
-        }
-    }
-    const results = runChecks(env);
+import { DEFAULTS, userDir } from '../../../core/config/index.js';
+import { expandPath, UserError } from '../../../core/util/index.js';
+import { createContext } from '../context.js';
+import { printJson, table } from '../../output/index.js';
+import { HealthService } from '../../services/index.js';
+const LABEL = {
+    ok: 'OK',
+    fixed: 'FIXED',
+    'needs-you': 'NEEDS YOU',
+    warn: 'WARNING',
+    skipped: 'SKIPPED',
+};
+export function repair(ctx, configError = null) {
+    const results = new HealthService(ctx).repair(configError);
     if (printJson(ctx, results))
         return results.some((r) => r.status === 'needs-you') ? 1 : 0;
     table(results.map((r) => [LABEL[r.status], r.name, r.detail]));
     const counts = _.countBy(results, 'status');
-    console.log('\n' + (counts['needs-you'] ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).' : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
+    console.log('\n' +
+        (counts['needs-you']
+            ? counts['needs-you'] + ' thing(s) need you (see NEEDS YOU above).'
+            : 'All good' + (counts.fixed ? ': fixed ' + counts.fixed + ' problem(s).' : '.')));
     return counts['needs-you'] ? 1 : 0;
-};
+}
 /**
  * Entry point that works even when the config file is broken (createContext would throw): falls back to the built-in
  * defaults so the other checks still run, and reports the config problem as the first check.
  */
-export const repairCommand = (packageRoot, entry, options) => {
+export function repairCommand(packageRoot, entry, options) {
     let ctx;
     try {
         ctx = createContext(packageRoot, entry, options);
@@ -55,7 +41,14 @@ export const repairCommand = (packageRoot, entry, options) => {
             throw e;
         const loaded = { config: structuredClone(DEFAULTS), configPath: null, base: userDir() };
         const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
-        return repair({ packageRoot, entry, options, loaded, storageRoot, dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName) }, e);
+        return repair({
+            packageRoot,
+            entry,
+            options,
+            loaded,
+            storageRoot,
+            dataPath: path.join(storageRoot, 'data', loaded.config.storage.dataName),
+        }, e);
     }
     return repair(ctx);
-};
+}

package/dist/cli/commands/repair/types.d.ts

@@ -1,4 +1,4 @@
-import type { UserError } from '../../../core/util.js';
+import type { UserError } from '../../../core/util/index.js';
 import type { Context } from '../context.js';
 export type RepairStatus = 'ok' | 'fixed' | 'needs-you' | 'warn' | 'skipped';
 export interface RepairResult {
@@ -18,7 +18,7 @@ export interface RepairCheck {
     name: string;
     run: (env: RepairEnv) => Omit<RepairResult, 'name'>;
 }
-export declare const ok: (detail: string) => Omit<RepairResult, "name">;
+export declare function ok(detail: string): Omit<RepairResult, 'name'>;
 /** For fixes that must not touch folders a running sandbox may be using. */
 export declare const whileRunning: {
     status: "skipped";

package/dist/cli/commands/repair/types.js

@@ -1,3 +1,8 @@
-export const ok = (detail) => ({ status: 'ok', detail });
+export function ok(detail) {
+    return { status: 'ok', detail };
+}
 /** For fixes that must not touch folders a running sandbox may be using. */
-export const whileRunning = { status: 'skipped', detail: 'a sandbox is running and may be using it; run repair again once it is closed' };
+export const whileRunning = {
+    status: 'skipped',
+    detail: 'a sandbox is running and may be using it; run repair again once it is closed',
+};

package/dist/cli/commands/resume.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from './context.js';
+export declare function resume(ctx: Context): Promise<number>;

package/dist/cli/commands/resume.js

@@ -0,0 +1,61 @@
+// `sandbox resume`: open the sessions of the last sandbox again. Starts the sandbox the way it was started when none
+// runs. `--auto` is how the background watcher calls it after a crash (resume.restartAfterCrash): no questions, and the
+// resume.sessions setting decides whether the sessions open ("ask" counts as "always" there: nobody is at the PC).
+import { sleep } from '../../core/util/index.js';
+import { SandboxChannel } from '../../host/channel/index.js';
+import { describeLast, LifeRecord, SessionLedger, shouldReopen } from '../../host/life/index.js';
+import { ProjectRegistry } from '../../host/projects/index.js';
+import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { requireOnPc } from './context.js';
+import { launch, RELAUNCHER } from './launch/index.js';
+import { freshContext, ledgerToReopen, notRunningYet, reopenedText, reopenSessions, sessionsToReopen, } from './sessions/reopen.js';
+/** Windows Sandbox needs a moment after the old one is gone before a new one can start. */
+const SETTLE_SECONDS = 30;
+/** Starts the sandbox again the way the ledger says it was started: its launch folder, agent and projects. */
+async function startAgain(ctx, saved) {
+    const again = freshContext(ctx, saved.launch.primary, saved.launch.harness ?? undefined, {
+        noAgent: saved.launch.harness === null,
+        headless: saved.launch.headless ? true : undefined,
+    });
+    return launch(again, false, { extraProjects: saved.launch.projects, autoSession: false, waitUntilReady: true });
+}
+export async function resume(ctx) {
+    requireOnPc('resume');
+    const { storageRoot, dataPath, options } = ctx;
+    const saved = new SessionLedger(storageRoot, dataPath).read();
+    if (!saved) {
+        console.log('Nothing to reopen: no sandbox of this tool has been recorded yet.');
+        return 0;
+    }
+    // By hand, you asked for it. From the watcher, the setting decides.
+    const setting = ctx.loaded.config.resume.sessions;
+    const life = new LifeRecord(storageRoot, dataPath).read();
+    const reopening = !options.auto || shouldReopen(setting === 'ask' ? 'always' : setting, life, saved) === 'reopen';
+    if (!options.auto && !saved.sessions.length) {
+        console.log('Nothing to reopen: no agent sessions were running in the last sandbox.');
+        return 0;
+    }
+    if (reopening && saved.sessions.length)
+        console.log('Last time: ' + describeLast(saved.sessions) + '.');
+    if (options.auto)
+        for (let i = 0; i < SETTLE_SECONDS && isSandboxRunning(); i++)
+            await sleep(1000);
+    if (!isSandboxRunning()) {
+        const code = await startAgain(ctx, saved);
+        if (code !== 0)
+            return code;
+    }
+    if (!reopening || !saved.sessions.length)
+        return 0;
+    const ready = await RELAUNCHER.readySandbox(ctx.dataPath);
+    const registry = new ProjectRegistry(storageRoot).read();
+    const open = registry ? sessionsToReopen(registry, new SandboxChannel(dataPath).currentSessions()) : [];
+    const reopen = notRunningYet(ledgerToReopen(saved.sessions), open);
+    if (!reopen.length) {
+        console.log('Everything from the last sandbox is open already.');
+        return 0;
+    }
+    const opened = await reopenSessions(ctx, ready, reopen, RELAUNCHER);
+    console.log(reopenedText(opened, reopen.length, reopen));
+    return opened === reopen.length ? 0 : 1;
+}

package/dist/cli/commands/sessions/attach.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from '../context.js';
+export declare function attach(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/attach.js

@@ -0,0 +1,44 @@
+import { select } from '@inquirer/prompts';
+import { safeText, sleep } from '../../../core/util/index.js';
+import { isWithin } from '../../../shared/paths/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { attachHere, readySandbox } from '../launch/index.js';
+import { locateHere } from '../projects/index.js';
+import { useSharedSandbox } from '../shared-use.js';
+import { ago } from '../../output/index.js';
+import { SessionsService } from '../../services/index.js';
+/** Asks which session to attach to, this folder's project first (the newest is the default). */
+function chooseSession(service, running, here) {
+    return select({
+        message: 'Which session?' + (here.project ? ' (' + here.project.name + ' first)' : ''),
+        choices: running.map((s) => ({
+            value: s.id,
+            name: (here.guestDir && isWithin(here.guestDir, s.cwd) ? '* ' : '  ') +
+                safeText(s.harness).padEnd(9) +
+                ' ' +
+                safeText(service.projectName(s)).padEnd(16) +
+                ' ' +
+                ago(s.startedAt).padEnd(11) +
+                ' ' +
+                s.id,
+        })),
+    });
+}
+export async function attach(asked) {
+    requireOnPc('attach');
+    requireRunning('Start one with: sandbox claude --terminal');
+    const ctx = await useSharedSandbox(asked, { kind: 'use' });
+    const ready = await readySandbox(ctx.dataPath);
+    const service = new SessionsService(ctx);
+    const id = ctx.options.positionals[0];
+    if (!id && service.runningCount() === 0)
+        await sleep(1500);
+    const here = locateHere(ctx, ready);
+    if (id)
+        return attachHere(ctx, service.pick(id));
+    // Several sessions: choose, this folder's project first (the newest is the default).
+    const running = service.running(here.guestDir);
+    if (running.length > 1 && process.stdin.isTTY && process.stdout.isTTY)
+        return attachHere(ctx, service.pick(await chooseSession(service, running, here)));
+    return attachHere(ctx, service.pick(undefined, here.guestDir));
+}

package/dist/cli/commands/sessions/control.d.ts

@@ -0,0 +1,4 @@
+import { type Context } from '../context.js';
+/** Restarts this folder's project's sessions (--all: every session). */
+export declare function restart(ctx: Context): Promise<number>;
+export declare function stop(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/control.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { askYesNo } from '../../../core/prompt.js';
+import { fail, safeText } from '../../../core/util/index.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { runningOwner } from '../../../host/sharing/index.js';
+import { useSharedSandbox } from '../shared-use.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { working, c } from '../../output/index.js';
+import { SandboxService, SessionsService } from '../../services/index.js';
+/** Restarts this folder's project's sessions (--all: every session). */
+export async function restart(ctx) {
+    requireOnPc('restart');
+    requireRunning();
+    await useSharedSandbox(ctx, { kind: 'owner-only', what: 'restart the agents' });
+    const service = new SessionsService(ctx);
+    const scope = service.restartScope(Boolean(ctx.options.all));
+    if (scope.notAProject)
+        console.log(c.dim(scope.folder + ' is not a project of the running sandbox: restarting every session.'));
+    console.log(safeText(await working('Restarting the agents' + (scope.guest ? ' of ' + scope.projectName : ''), () => service.restart(ctx.options.harness ?? null, scope.guest))));
+    return 0;
+}
+/**
+ * Stopping ends every project's sessions: other projects' sessions need a yes (or --yes). A script must never end them
+ * by accident, so without a terminal to ask in it fails.
+ */
+async function othersMayEnd(ctx, others) {
+    if (!others.length || ctx.options.yes)
+        return true;
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    if (!interactive)
+        fail(others.length + ' of these sessions belong to other projects, so the sandbox was not stopped.', 'Stop it anyway with: sandbox stop --yes');
+    return askYesNo(others.length + ' of them belong to other projects. Stop the whole sandbox?');
+}
+export async function stop(asked) {
+    requireOnPc('stop');
+    if (!new SandboxService(asked).isRunning()) {
+        console.log('No Windows Sandbox is running.');
+        return 0;
+    }
+    // Another user's sandbox: only when shared, and only after typing their name (--yes in scripts).
+    let ctx = asked;
+    if (runningOwner().kind !== 'mine') {
+        ctx = await useSharedSandbox(asked, (shared) => ({
+            kind: 'stop',
+            sessions: new SandboxChannel(shared.dataPath).currentSessions().length,
+        }));
+    }
+    const service = new SandboxService(ctx);
+    // Stopping ends every project's sessions, not just this folder's: say which, and ask when others would end too.
+    const { sandbox, running, others } = service.stopPlan();
+    if (running.length)
+        console.log('Stopping ends ' +
+            running.length +
+            ' session(s): ' +
+            running
+                .map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd)))
+                .join(', ') +
+            '.');
+    if (!(await othersMayEnd(ctx, others))) {
+        console.log('Nothing changed.');
+        return 1;
+    }
+    await working('Asking the sandbox to shut down', () => service.shutdown(sandbox));
+    console.log('Sandbox is shutting down; history and claude-mem sync back when it closes.');
+    return 0;
+}

package/dist/cli/commands/sessions/exec.d.ts

@@ -0,0 +1,6 @@
+import { type Context } from '../context.js';
+export declare function exec(asked: Context): Promise<number>;
+/**
+ * `sandbox db`: runs the sandbox's own `sbx-db` in this folder's project, which knows its database versions and ports.
+ */
+export declare function db(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/exec.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { NeedsRestart } from '../../../host/projects/index.js';
+import { fail, safeText } from '../../../core/util/index.js';
+import { printJson, working } from '../../output/index.js';
+import { requireOnPc, requireRunning } from '../context.js';
+import { readySandbox } from '../launch/index.js';
+import { hereDir, joinHere, provisionJoined } from '../projects/index.js';
+import { useSharedSandbox } from '../shared-use.js';
+import { DatabasesService } from '../../services/index.js';
+/** What a command run in the sandbox printed (text from the sandbox: through safeText), or why it failed. */
+function printExecResult(result) {
+    if (result.stdout)
+        process.stdout.write(safeText(result.stdout));
+    if (result.stderr)
+        process.stderr.write(safeText(result.stderr));
+    if (!result.ok && !result.stdout && !result.stderr)
+        console.error(safeText(result.message));
+}
+/** The guest folder for this folder, joining the running sandbox (and setting the project up) when needed. */
+async function guestFolderHere(ctx, what) {
+    const ready = await readySandbox(ctx.dataPath);
+    try {
+        // A command needs no restart for what the project wants at boot: it runs without them (and says so).
+        const joined = await joinHere(ctx, ready, { noRestart: true });
+        for (const note of joined.notes)
+            console.error(note);
+        await provisionJoined(ctx, joined);
+        return joined.guestDir;
+    }
+    catch (e) {
+        if (!(e instanceof NeedsRestart))
+            throw e;
+        return fail(hereDir(ctx) + ' is not in the running sandbox (' + e.reason + '), so "sandbox ' + what + '" cannot run there.', 'sandbox claude (or sandbox start) from that folder offers a restart that adds it; or add its parent folder as a root: sandbox projects roots add "' +
+            path.dirname(e.hostDir) +
+            '"');
+    }
+}
+export async function exec(asked) {
+    const command = [...asked.options.positionals, ...asked.options.passthrough];
+    if (command.length === 0)
+        fail('No command given.', 'Usage: sandbox exec [--timeout <s>] -- <command> [args...]');
+    requireOnPc('exec');
+    requireRunning();
+    const ctx = await useSharedSandbox(asked, { kind: 'use' });
+    const cwd = await guestFolderHere(ctx, 'exec');
+    const result = await new SandboxChannel(ctx.dataPath).exec(command, cwd, ctx.options.timeout);
+    if (!printJson(ctx, result))
+        printExecResult(result);
+    return result.exitCode ?? 1;
+}
+/**
+ * `sandbox db`: runs the sandbox's own `sbx-db` in this folder's project, which knows its database versions and ports.
+ */
+export async function db(asked) {
+    const [rawAction = 'list', name] = asked.options.positionals;
+    const first = new DatabasesService(asked);
+    const action = first.validate(rawAction, name);
+    // Already inside the sandbox: run the database tool here instead of asking the sandbox from outside.
+    if (first.isInsideSandbox())
+        return first.runInside(action, name);
+    requireRunning('Start one with: sandbox start --database <name>');
+    const ctx = await useSharedSandbox(asked, { kind: 'use' });
+    const databases = new DatabasesService(ctx);
+    const cwd = await guestFolderHere(ctx, 'db');
+    const result = await working((action === 'list' ? 'Asking' : action === 'start' ? 'Starting' : 'Stopping') +
+        ' the database' +
+        (name ? ' ' + name : 's') +
+        ' in the sandbox', () => databases.run(action, name, cwd));
+    printExecResult(result);
+    return result.exitCode ?? 1;
+}

package/dist/cli/commands/sessions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './attach.js';
+export * from './list.js';
+export * from './status.js';
+export * from './exec.js';
+export * from './control.js';
+export * from './window.js';

package/dist/cli/commands/sessions/index.js

@@ -0,0 +1,9 @@
+// Working with a running sandbox: attach, sessions, status, exec, restart, stop, show/hide. Each knows which project
+// you run it from (project.ts): attach and sessions put that project's sessions first, exec and db run in it, restart
+// restarts its sessions, stop warns about the other projects' sessions.
+export * from './attach.js';
+export * from './list.js';
+export * from './status.js';
+export * from './exec.js';
+export * from './control.js';
+export * from './window.js';

package/dist/cli/commands/sessions/list.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from '../context.js';
+export declare function sessions(asked: Context): Promise<number>;

package/dist/cli/commands/sessions/list.js

@@ -0,0 +1,45 @@
+import _ from 'lodash';
+import { safeText } from '../../../core/util/index.js';
+import { printJson, table, ago, c, shortenMiddle, termWidth } from '../../output/index.js';
+import { SessionsService, viewerText } from '../../services/index.js';
+import { lookAtSandbox } from '../shared-use.js';
+export async function sessions(asked) {
+    // Another user's sandbox: shared, its sessions are listed from their folders; not shared, only whose it is.
+    const view = lookAtSandbox(asked);
+    const ctx = view.ctx;
+    if (view.limited) {
+        if (!printJson(ctx, []))
+            console.log(view.line);
+        return 0;
+    }
+    if (view.line && !ctx.options.json)
+        console.log(c.bold(view.line));
+    const service = new SessionsService(ctx);
+    const list = await service.list();
+    if (printJson(ctx, list.map((s) => _.omit(s, 'attach'))))
+        return 0;
+    if (list.length === 0) {
+        console.log('No sessions. Start one with: sandbox claude');
+        return 0;
+    }
+    // Harness, cwd and times are written by the sandbox.
+    const folderWidth = Math.max(16, termWidth() - 80);
+    table([
+        ['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', 'FOLDER', 'STARTED'],
+        ...service
+            .ordered(list)
+            .map((s) => [
+            s.here ? '*' : '',
+            s.id,
+            safeText(s.harness),
+            safeText(s.projectName ?? '-'),
+            s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : ''),
+            viewerText(s.viewers),
+            shortenMiddle(safeText(s.cwd), folderWidth),
+            ago(s.startedAt),
+        ]),
+    ]);
+    if (list.some((s) => s.here))
+        console.log(c.dim('* = the project of this folder'));
+    return 0;
+}

package/dist/cli/commands/sessions/reopen.d.ts

@@ -0,0 +1,36 @@
+import type { SandboxStatus, SessionStatus } from '../../../core/types.js';
+import type { LedgerSession } from '../../../host/life/index.js';
+import type { Registry } from '../../../host/projects/index.js';
+import type { CliOptions } from '../../args.js';
+import type { Context } from '../context.js';
+import type { LaunchExtras, OpenSessionOptions } from '../launch/index.js';
+import type { Joined } from '../projects/here.js';
+/** What a restart or resume needs from launch (launch imports them, so it is handed in rather than imported). */
+export interface Relauncher {
+    launch(ctx: Context, generateOnly: boolean, extras: LaunchExtras): Promise<number>;
+    readySandbox(dataPath: string): Promise<SandboxStatus>;
+    joinHere(ctx: Context, status: SandboxStatus, o?: {
+        noRestart?: boolean;
+    }): Promise<Joined>;
+    openSession(ctx: Context, ready: SandboxStatus, joined: Joined, o: OpenSessionOptions): Promise<number>;
+}
+/** A session to open again: its agent, its folder on this PC and the conversation it was in (when known). */
+export interface Reopen {
+    readonly harness: string;
+    readonly hostDir: string;
+    readonly conversation?: string;
+}
+/** Where each running session is on this PC, so it can be reopened after a restart. */
+export declare function sessionsToReopen(registry: Registry, sessions: readonly SessionStatus[]): Reopen[];
+/** The sessions the last sandbox had, as sessions to open. */
+export declare function ledgerToReopen(sessions: readonly LedgerSession[]): Reopen[];
+/** Leaves out sessions the sandbox has already (same agent, same folder): reopening them would double them. */
+export declare function notRunningYet(reopen: readonly Reopen[], running: readonly Reopen[]): Reopen[];
+/** The same command for another folder, as a plain new session (nothing attached, no agent arguments). */
+export declare function freshContext(ctx: Context, workspace: string, harness: string | undefined, more?: Partial<CliOptions>): Context;
+/** The arguments that continue this session (its conversation when the agent can open one by id). */
+export declare function continueArguments(ctx: Context, s: Reopen): string[];
+/** Opens each session again; one that cannot be opened is said and skipped. Returns how many opened. */
+export declare function reopenSessions(ctx: Context, ready: SandboxStatus, reopen: readonly Reopen[], relauncher: Relauncher): Promise<number>;
+/** "Reopened 2 sessions (continuing their conversations)." */
+export declare function reopenedText(opened: number, wanted: number, reopen: readonly Reopen[]): string;

package/dist/cli/commands/sessions/reopen.js

@@ -0,0 +1,99 @@
+// Opening sessions again in a sandbox that just started: after a restart that adds folders (projects/restart.ts), and
+// after a launch or `sandbox resume` that picks up what ran last time. Each session opens in its own folder with the
+// arguments that continue its conversation: the one it was in when the agent can open it by id, else the agent's last.
+import _ from 'lodash';
+import { errMsg } from '../../../core/util/index.js';
+import { hostDirFor, projectForGuestDir, resumeArgumentsFor } from '../../../shared/paths/index.js';
+import { c } from '../../output/index.js';
+/** Where each running session is on this PC, so it can be reopened after a restart. */
+export function sessionsToReopen(registry, sessions) {
+    return sessions.flatMap((s) => {
+        const project = projectForGuestDir([...registry.projects, ...registry.roots.map((r) => ({ ...r }))], s.cwd);
+        return project
+            ? [
+                {
+                    harness: s.harness,
+                    hostDir: hostDirFor(project, s.cwd),
+                    ...(s.conversation ? { conversation: s.conversation } : {}),
+                },
+            ]
+            : [];
+    });
+}
+/** The sessions the last sandbox had, as sessions to open. */
+export function ledgerToReopen(sessions) {
+    return sessions.map((s) => ({
+        harness: s.harness,
+        hostDir: s.project,
+        ...(s.conversation ? { conversation: s.conversation } : {}),
+    }));
+}
+/** Leaves out sessions the sandbox has already (same agent, same folder): reopening them would double them. */
+export function notRunningYet(reopen, running) {
+    const taken = [...running];
+    return reopen.filter((r) => {
+        const at = taken.findIndex((t) => t.harness === r.harness && t.hostDir.toLowerCase() === r.hostDir.toLowerCase());
+        if (at < 0)
+            return true;
+        taken.splice(at, 1);
+        return false;
+    });
+}
+/** The same command for another folder, as a plain new session (nothing attached, no agent arguments). */
+export function freshContext(ctx, workspace, harness, more = {}) {
+    return {
+        ...ctx,
+        options: {
+            ...ctx.options,
+            workspace,
+            harness,
+            terminal: false,
+            newSession: true,
+            passthrough: [],
+            sessions: [],
+            ...more,
+        },
+    };
+}
+/** The arguments that continue this session (its conversation when the agent can open one by id). */
+export function continueArguments(ctx, s) {
+    const harness = ctx.loaded.config.harnesses[s.harness];
+    return harness ? resumeArgumentsFor(harness, s.conversation) : [];
+}
+/** Opens each session again; one that cannot be opened is said and skipped. Returns how many opened. */
+export async function reopenSessions(ctx, ready, reopen, relauncher) {
+    let opened = 0;
+    for (const s of reopen) {
+        const at = freshContext(ctx, s.hostDir, s.harness);
+        try {
+            const joined = await relauncher.joinHere(at, ready, { noRestart: true });
+            for (const note of joined.notes)
+                console.log(note);
+            await relauncher.openSession(at, ready, joined, {
+                attach: false,
+                harness: s.harness,
+                args: continueArguments(ctx, s),
+                reuse: false,
+            });
+            opened++;
+        }
+        catch (e) {
+            console.warn(c.yellow('Could not reopen ' + s.harness + ' in ' + s.hostDir + ': ' + errMsg(e)));
+        }
+    }
+    return opened;
+}
+/** "Reopened 2 sessions (continuing their conversations)." */
+export function reopenedText(opened, wanted, reopen) {
+    const same = _.every(reopen, (s) => Boolean(s.conversation));
+    return ('Reopened ' +
+        opened +
+        (opened === wanted ? '' : ' of ' + wanted) +
+        ' session' +
+        (opened === 1 ? '' : 's') +
+        (opened
+            ? same
+                ? ' (continuing their conversations).'
+                : ' (continuing the last conversation of each agent).'
+            : '.'));
+}

package/dist/cli/commands/sessions/status.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../context.js';
+export declare function status(asked: Context): Promise<number>;