windows-development-sandbox 1.4.3 → 1.7.0

package/dist/cli/args.js

@@ -2,9 +2,10 @@
 // dispatches the result. sandbox claude & co parse as `launch`: every option launch does not own goes to the agent, in
 // order.
 import path from 'node:path';
-import { Command, InvalidArgumentError, Option } from 'commander';
+import { Argument, Command, InvalidArgumentError, Option } from 'commander';
 import { fail } from '../core/util/index.js';
 import { c } from './output/index.js';
+import { insideSandbox } from '../host/sandbox/index.js';
 import { COMMANDS } from './manifest.js';
 import { packageVersion } from '../core/package-info.js';
 /** Splits a command line like a shell: "quoted words" and 'quoted words' stay together. */
@@ -38,45 +39,109 @@ function positiveNumber(value) {
 function collect(value, previous = []) {
     return [...previous, value];
 }
-/** One commander option from its manifest entry. */
-function toOption(o) {
-    const flags = (o.short ? o.short + ', ' : '') + o.flag + (o.type === 'boolean' ? '' : ' <' + (o.value ?? 'value') + '>');
-    const option = new Option(flags, o.description);
-    if (o.type === 'number')
-        option.argParser(positiveNumber);
-    if (o.type === 'list')
-        option.argParser(collect);
-    if (o.default !== undefined)
-        option.default(o.default);
-    return option;
+/** Commands in --help, group by group, in this order (a command not listed comes last in its group). */
+const HELP_ORDER = [
+    ['Agents', ['launch', 'start', 'resume', 'restart', 'stop', 'host']],
+    ['Sessions', ['sessions', 'attach', 'status', 'exec', 'show', 'hide', 'db']],
+    ['Projects & accounts', ['projects', 'account']],
+    ['Data', ['data', 'storage', 'clean', 'sync']],
+    ['Web', ['web']],
+    ['Health', ['setup', 'doctor', 'repair', 'logs', 'audit', 'update', 'migrate', 'config']],
+    ['Advanced', ['generate', 'agent-commands', 'vpn']],
+];
+/** The commands in the order --help lists them. */
+function helpOrdered() {
+    const flat = HELP_ORDER.flatMap(([, names]) => names);
+    const rank = (name) => {
+        const i = flat.indexOf(name);
+        return i < 0 ? flat.length : i;
+    };
+    return [...COMMANDS].sort((x, y) => rank(x.name) - rank(y.name));
+}
+/** The options of one manifest entry: the visible one, and a hidden old spelling when `shownAs` renames it. */
+function toOptions(o, wrapper) {
+    const shown = o.shownAs && !wrapper ? o.shownAs : o.flag;
+    const placeholder = o.type === 'boolean' ? '' : ' <' + (o.value ?? 'value') + '>';
+    const make = (flag) => {
+        const option = new Option((o.short ? o.short + ', ' : '') + flag + placeholder, o.description);
+        if (o.type === 'number')
+            option.argParser(positiveNumber);
+        if (o.type === 'list')
+            option.argParser(collect);
+        if (o.default !== undefined)
+            option.default(o.default);
+        if (o.group)
+            option.helpGroup(o.group + ':');
+        return option;
+    };
+    const visible = make(shown);
+    return shown === o.flag ? [visible] : [visible, make(o.flag).hideHelp()];
+}
+/** A positional argument; fixed choices are checked by the parser and listed in --help. */
+function toArgument(arg) {
+    const name = (arg.required ? '<' : '[') + arg.name + (arg.variadic ? '...' : '') + (arg.required ? '>' : ']');
+    const argument = new Argument(name, arg.description);
+    if (Array.isArray(arg.choices)) {
+        argument.choices(arg.choices);
+        const aliases = arg.aliases ?? [];
+        const check = argument.parseArg;
+        if (aliases.length && check)
+            argument.argParser((value, previous) => aliases.includes(value) ? value : check(value, previous));
+    }
+    return argument;
+}
+/** "Unknown command" with the suggestion in our words; other commander errors only lose the lower-case start. */
+export function friendlyError(text) {
+    const m = /^error: unknown command '(.*)'\n\(Did you mean (.*)\?\)\n?$/.exec(text);
+    if (m) {
+        const names = m[2].replace(/^one of /, '').split(', ');
+        return 'Unknown command "' + m[1] + '". Did you mean: ' + names.map((n) => 'sandbox ' + n).join(' or ') + '?\n';
+    }
+    return text.replace(/^error: /, '').replace(/^./, (ch) => ch.toUpperCase());
+}
+function rootHelp() {
+    const lines = [
+        '',
+        'Start an agent by name: sandbox claude, sandbox codex ... (the same as sandbox launch --agent <name>).',
+        'Put --config <file> before or after the command to use another settings file.',
+    ];
+    if (insideSandbox())
+        lines.push('You are inside a sandbox: launch, resume, attach, restart, stop, exec, show, hide, storage and web control it from your PC and do not work here.');
+    lines.push('', 'Examples:', '  sandbox                       the menu', '  sandbox claude -t             start Claude and attach this terminal', '  sandbox data clean logs       delete the saved logs', '  sandbox exec -- npm test      run a command in the running sandbox');
+    return lines.join('\n');
 }
-/** Every command, its options and help text, from manifest.ts. Actions only record what was parsed. */
-export function buildProgram(record) {
+/**
+ * Every command, its options and help text, from manifest.ts. Actions only record what was parsed. `wrapper` = the
+ * sandbox <agent> spelling: --agent stays the agent's own flag there (Claude has one), only --harness is ours.
+ */
+export function buildProgram(record, wrapper = false) {
     const program = new Command('sandbox')
         .description('A disposable Windows Sandbox for development, with or without an AI agent, for the folder you are in. Run it with no arguments for the menu.')
         .version(packageVersion(), '-v, --version', 'show the version')
         .enablePositionalOptions()
         .showHelpAfterError('  Fix:  run the command with --help to see how to use it.')
-        .configureOutput({
-        outputError: (text, write) => write(c.red('Error: ') + text.replace(/^error: /, '').replace(/^./, (ch) => ch.toUpperCase())),
-    })
-        .addHelpText('after', '\nPut --config <file> before or after the command to use another settings file.\nExamples:\n  sandbox                       the menu\n  sandbox claude -t             start Claude and attach this terminal\n  sandbox data clean logs       delete the saved logs\n  sandbox exec -- npm test      run a command in the running sandbox')
+        .configureOutput({ outputError: (text, write) => write(c.red('Error: ') + friendlyError(text)) })
+        .addHelpText('after', rootHelp)
         .exitOverride();
-    for (const spec of COMMANDS) {
+    for (const spec of helpOrdered()) {
         const cmd = program
             .command(spec.name, { hidden: spec.hidden })
             .description(spec.summary)
-            .option('--config <file>', 'config file (default: ~/.agent-sandbox/config.json)');
+            .helpGroup(spec.group + ':')
+            .addOption(new Option('--config <file>', 'config file (default: ~/.agent-sandbox/config.json)').hideHelp());
         for (const option of spec.options)
-            cmd.addOption(toOption(option));
+            for (const o of toOptions(option, wrapper))
+                cmd.addOption(o);
         if (spec.json)
             cmd.option('--json', 'machine-readable output');
         for (const arg of spec.args)
-            cmd.argument((arg.required ? '<' : '[') + arg.name + (arg.variadic ? '...' : '') + (arg.required ? '>' : ']'), arg.description);
+            cmd.addArgument(toArgument(arg));
         if (spec.passthrough === 'agent')
             cmd.argument('[agentArgs...]', 'passed to the agent').allowUnknownOption().allowExcessArguments();
         if (spec.passthrough === 'command')
             cmd.passThroughOptions();
+        if (spec.examples?.length)
+            cmd.addHelpText('after', '\nExamples:\n' + spec.examples.map((l) => '  ' + l).join('\n'));
         cmd.action((...args) => record(spec.name, args[args.length - 1]));
     }
     return program;
@@ -99,7 +164,7 @@ export function parseCli(argv, wrapper = false) {
     let parsed = null;
     const program = buildProgram((name, cmd) => {
         parsed = { name, cmd };
-    });
+    }, wrapper);
     const launchFlags = new Set(program.commands
         .find((c) => c.name() === 'launch')
         .options.map((o) => o.long)
@@ -110,7 +175,7 @@ export function parseCli(argv, wrapper = false) {
         return { ...defaults(), command: '' };
     const { name, cmd } = parsed;
     const o = { ...program.opts(), ...cmd.opts() };
-    const forAgent = ['launch', 'start', 'generate', 'host-claude'].includes(name);
+    const forAgent = ['launch', 'start', 'generate', 'host-claude', 'host'].includes(name);
     // Commander keeps our `--` separator among the operands when unknown options are allowed; it is ours, not the
     // agent's.
     const separator = forAgent ? cmd.args.indexOf('--') : -1;
@@ -123,7 +188,7 @@ export function parseCli(argv, wrapper = false) {
         passthrough: forAgent || name === 'exec' ? operands : [],
         config: o.config,
         workspace: o.workspace,
-        harness: o.harness,
+        harness: o.harness ?? (name !== 'account' && typeof o.agent === 'string' ? o.agent : undefined),
         account: o.account,
         node: o.node,
         python: o.python,
@@ -140,18 +205,39 @@ export function parseCli(argv, wrapper = false) {
         noLocalConfig: o.localConfig === false,
         personal: Boolean(o.personal),
         fromHost: Boolean(o.fromHost),
+        accountAgent: name === 'account' && typeof o.agent === 'string' ? o.agent : undefined,
+        accountTo: name === 'account' && typeof o.to === 'string' ? o.to : undefined,
         noRestart: o.restart === false,
         follow: Boolean(o.follow),
         json: Boolean(o.json),
         yes: Boolean(o.yes),
+        wide: Boolean(o.wide),
+        keepOld: Boolean(o.keepOld),
         all: Boolean(o.all),
         sessions: (o.session ?? []).map((s) => parseSessionWant(s)),
         timeout: o.timeout ?? 600,
         days: o.days ?? (name === 'audit' ? 1 : 7),
         kind: o.kind,
         grep: o.grep,
+        dryRun: Boolean(o.dryRun),
+        fix: Boolean(o.fix),
+        auto: o.auto === true,
+        restore: o.restore,
+        check: Boolean(o.check),
+        rollback: Boolean(o.rollback),
+        unattended: Boolean(o.unattended),
+        feed: o.feed,
+        autoUpdate: updateAuto(o.auto),
     };
 }
+/** `update --auto on|off` (the same flag is a switch for resume): anything else is refused. */
+function updateAuto(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (value === 'on' || value === 'off')
+        return value;
+    return fail('--auto needs on or off.', 'Use sandbox update --auto on, or --auto off.');
+}
 function defaults() {
     return {
         command: '',
@@ -168,8 +254,16 @@ function defaults() {
         fromHost: false,
         noRestart: false,
         follow: false,
+        dryRun: false,
+        fix: false,
+        auto: false,
+        check: false,
+        rollback: false,
+        unattended: false,
         json: false,
         yes: false,
+        wide: false,
+        keepOld: false,
         all: false,
         sessions: [],
         timeout: 600,

package/dist/cli/commands/accounts.js

@@ -1,23 +1,22 @@
-// `account list | save | use | default | remove`
-import { AccountStore, hostClaudeDir, hostGlobalStateFile } from '../../host/profile/index.js';
-import { SandboxChannel } from '../../host/channel/index.js';
-import { isSandboxRunning } from '../../host/sandbox/index.js';
+// `account list | save | use | default | rename | remove [--agent <name>]`
+import { askChoice, askName, askRequired } from '../../core/prompt.js';
 import { fail, safeText } from '../../core/util/index.js';
-import { printJson, table } from '../output/index.js';
+import { nextStep, printJson, table } from '../output/index.js';
+import { AccountsService } from '../services/index.js';
 function label(a) {
     return '"' + a.name + '"' + (a.email ? ' (' + a.email + ')' : '');
 }
-/** This PC's Claude login location (config folder + global state file). */
-function hostLogin(ctx) {
-    const profile = ctx.loaded.config.claudeProfile;
-    return { claudeDir: hostClaudeDir(profile), globalStateFile: hostGlobalStateFile(profile) };
-}
-function list(ctx) {
-    const rows = new AccountStore(ctx.storageRoot).list(ctx.dataPath);
+function list(ctx, accounts, agent) {
+    const rows = accounts.list(agent);
     if (printJson(ctx, rows))
         return 0;
     if (rows.length === 0) {
-        console.log("No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC's login)");
+        console.log(agent === 'claude'
+            ? "No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC's login)"
+            : 'No saved ' +
+                agent +
+                ' accounts. Sign in inside the sandbox, then: sandbox account save <name> --agent ' +
+                agent);
         return 0;
     }
     table([
@@ -32,36 +31,66 @@ function list(ctx) {
     console.log('\n* = active in the sandbox   D = default for new launches');
     return 0;
 }
-async function use(ctx, name) {
-    console.log('Sandbox now uses ' + label(new AccountStore(ctx.storageRoot).activate(ctx.dataPath, name)) + '.');
-    const claudeRunning = isSandboxRunning() && new SandboxChannel(ctx.dataPath).runningSessions().some((s) => s.harness === 'claude');
-    if (claudeRunning && !ctx.options.noRestart)
-        console.log(safeText((await new SandboxChannel(ctx.dataPath).restart('claude')).message) +
-            ' with --continue; the conversation carries on under the new account.');
+async function use(ctx, accounts, name, agent) {
+    const used = accounts.activate(name, agent);
+    console.log('Sandbox now uses ' + label(used) + '.');
+    if (used.note)
+        console.log(safeText(used.note));
+    if (accounts.hasRunningSessions(agent) && !ctx.options.noRestart)
+        console.log(safeText(await accounts.restart(agent)) + ' with --continue; the conversation carries on under the new account.');
+    return 0;
+}
+/** The account the command is about: the one typed, or one picked from the saved accounts. */
+async function accountName(accounts, action, agent, given) {
+    if (given)
+        return given;
+    const usage = 'Usage: sandbox account ' + action + ' <name>';
+    if (action === 'save')
+        return askName('Name for this login:', usage, (v) => v.length > 0 || 'Type a name.');
+    const rows = accounts.list(agent);
+    if (!rows.length)
+        fail('No saved accounts.', 'Sign in inside the sandbox, then run: sandbox account save <name>');
+    return askChoice('Which account?', rows.map((a) => ({ name: safeText(label(a)), value: a.name })), usage);
+}
+async function remove(ctx, accounts, name, agent) {
+    const sure = ctx.options.yes ||
+        (await askRequired('Remove the saved account "' + name + '"? Its login cannot be recovered; you would sign in again.', 'Add --yes to remove it without asking.'));
+    if (!sure) {
+        console.log('Nothing removed.');
+        return 1;
+    }
+    accounts.remove(name, agent);
+    console.log('Removed account ' + name + '.');
     return 0;
 }
 export async function account(ctx) {
-    const [action = 'list', name] = ctx.options.positionals;
-    const needName = () => name ?? fail('Missing account name.', 'Usage: sandbox account ' + action + ' <name>');
+    const [action = 'list', given] = ctx.options.positionals;
+    const agent = ctx.options.accountAgent ?? 'claude';
+    const accounts = new AccountsService(ctx);
+    if (action === 'list')
+        return list(ctx, accounts, agent);
+    const name = await accountName(accounts, action, agent, given);
     switch (action) {
-        case 'list':
-            return list(ctx);
         case 'save':
-            console.log('Saved account ' +
-                label(new AccountStore(ctx.storageRoot).save(ctx.dataPath, needName(), ctx.options.fromHost ? hostLogin(ctx) : null)) +
-                '.');
+            console.log('Saved account ' + label(accounts.save(name, Boolean(ctx.options.fromHost), agent)) + '.');
+            nextStep('sandbox account use ' + name + '   (the sandbox uses it)');
             return 0;
         case 'use':
-            return use(ctx, needName());
+            return use(ctx, accounts, name, agent);
         case 'default':
-            new AccountStore(ctx.storageRoot).setDefault(needName());
+            accounts.setDefault(name, agent);
             console.log('Default account: ' + name);
             return 0;
-        case 'remove':
-            new AccountStore(ctx.storageRoot).remove(needName());
-            console.log('Removed account ' + name);
+        case 'rename': {
+            const to = ctx.options.accountTo ??
+                (await askName('New name for "' + name + '":', 'Usage: sandbox account rename <name> --to <new-name>', (v) => v.length > 0 || 'Type a name.'));
+            accounts.rename(name, to, agent);
+            console.log('Renamed account ' + name + ' to ' + to + '.');
             return 0;
+        }
+        case 'remove':
+            return remove(ctx, accounts, name, agent);
         default:
-            fail('Unknown account action "' + action + '".', 'Use one of: sandbox account list | save <name> | use <name> | default <name> | remove <name>');
+            return fail('Unknown account action "' + action + '".', 'Use one of: sandbox account list | save <name> | use <name> | default <name> | rename <name> --to <new-name> | remove <name>');
     }
 }

package/dist/cli/commands/agent-commands.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from '../../core/types.js';
-import { type Reconciled } from '../../host/agent-commands/index.js';
+import type { Reconciled } from '../../host/agent-commands/index.js';
 import { type Context } from './context.js';
 /** Brings this PC in line with agentCommands and says what changed (used after on/off, settings and launch). */
 export declare function syncAgentCommands(ctx: Context, config: Config, quiet?: boolean): Reconciled | null;

package/dist/cli/commands/agent-commands.js

@@ -1,22 +1,10 @@
-// `sandbox agent-commands [status|on|off]` (Beta): typing claude, codex ... on this PC starts them in a hidden sandbox.
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadConfig, userConfigPath } from '../../core/config/index.js';
 import { fail } from '../../core/util/index.js';
-import { agentCommands, commandsDir, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
-import { insideSandbox } from '../../host/sandbox/index.js';
-import { writeFileAtomic } from '../../shared/io/index.js';
 import { c, table } from '../output/index.js';
-import { editConfigText } from '../menu/settings/index.js';
-function entryOf(ctx) {
-    return path.join(ctx.packageRoot, 'dist', 'bin', 'sandbox.js');
-}
+import { AgentCommandsService } from '../services/index.js';
 /** Brings this PC in line with agentCommands and says what changed (used after on/off, settings and launch). */
 export function syncAgentCommands(ctx, config, quiet = false) {
-    if (insideSandbox())
-        return null;
-    const result = reconcileAgentCommands(config, ctx.storageRoot, process.execPath, entryOf(ctx));
-    if (!result.changed || quiet)
+    const result = new AgentCommandsService(ctx).reconcile(config);
+    if (!result || !result.changed || quiet)
         return result;
     if (result.on) {
         console.log('Agent commands (Beta) are on for: ' +
@@ -28,36 +16,23 @@ export function syncAgentCommands(ctx, config, quiet = false) {
     return result;
 }
 export function agentCommandsCommand(ctx) {
-    if (insideSandbox())
-        fail("Agent commands change your PC's PATH, so they are set up from your PC, not inside the sandbox.", 'Run sandbox agent-commands on in a terminal on your PC.');
+    const service = new AgentCommandsService(ctx);
+    service.assertOnPc();
     const action = ctx.options.positionals[0] ?? 'status';
     if (action === 'status') {
-        const config = ctx.loaded.config;
-        const found = agentCommands(config, ctx.storageRoot);
-        console.log('Agent commands (Beta): ' +
-            (config.agentCommands.enabled ? c.green('on') : 'off') +
-            c.dim('  (' + commandsDir(ctx.storageRoot) + ')'));
+        const { enabled, dir, found } = service.status();
+        console.log('Agent commands (Beta): ' + (enabled ? c.green('on') : 'off') + c.dim('  (' + dir + ')'));
         if (found.length)
-            table(found.map((a) => [
-                a.command,
-                'sandboxed ' + a.harness + (config.agentCommands.enabled ? '' : ' when on'),
-                c.dim('real: ' + a.real),
-            ]));
+            table(found.map((a) => [a.command, 'sandboxed ' + a.harness + (enabled ? '' : ' when on'), c.dim('real: ' + a.real)]));
         else
             console.log(c.dim('No agents found on this PC (claude, codex, gemini ... on your PATH).'));
-        if (!config.agentCommands.enabled)
+        if (!enabled)
             console.log(c.dim('Turn on with: sandbox agent-commands on'));
         return 0;
     }
     if (action !== 'on' && action !== 'off')
         fail('Unknown action "' + action + '".', 'Use: sandbox agent-commands [status|on|off]');
-    const file = ctx.loaded.configPath ?? userConfigPath();
-    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-    const edited = editConfigText(text, ['agentCommands', 'enabled'], action === 'on' ? true : undefined);
-    if ('problems' in edited)
-        fail('Could not change ' + file + ': ' + edited.problems.join('; '), 'Fix the file with sandbox config check, then try again.');
-    writeFileAtomic(file, edited.text);
-    const result = syncAgentCommands(ctx, loadConfig(file).config, true);
+    const result = service.setEnabled(action === 'on');
     if (result?.on) {
         console.log('Agent commands (Beta) are on: ' +
             (result.commands.map((a) => a.command).join(', ') || 'no installed agents found yet'));

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

@@ -1,5 +1,6 @@
 import type { CliOptions } from '../args.js';
 import type { LoadedConfig } from '../../core/types.js';
+import type { Borrowed } from '../../host/sharing/index.js';
 export interface Context {
     packageRoot: string;
     entry: string;
@@ -7,8 +8,15 @@ export interface Context {
     loaded: LoadedConfig;
     storageRoot: string;
     dataPath: string;
+    /**
+     * Set when the running sandbox is another user's and shared with this one: dataPath is then their data folder, and
+     * its projects come from their record. Only the commands in shared-use.ts make such a context.
+     */
+    borrowed?: Borrowed;
 }
 export declare function createContext(packageRoot: string, entry: string, options: CliOptions): Context;
+/** Reads the config again and takes the storage folder from it (after a migration or a move changed it). */
+export declare function refreshStorage(ctx: Context): void;
 /** For commands that control the sandbox from your PC: inside the sandbox they make no sense. */
 export declare function requireOnPc(what: string): void;
 export declare function requireRunning(hint?: string): void;

package/dist/cli/commands/context.js

@@ -36,14 +36,21 @@ export function createContext(packageRoot, entry, options) {
         dataPath: insideSandbox() ? GUEST_DATA_DIR : path.join(storageRoot, 'data', loaded.config.storage.dataName),
     };
 }
+/** Reads the config again and takes the storage folder from it (after a migration or a move changed it). */
+export function refreshStorage(ctx) {
+    ctx.loaded = loadConfig(ctx.options.config);
+    ctx.storageRoot = expandPath(ctx.loaded.config.storage.root, ctx.loaded.base);
+    if (!insideSandbox())
+        ctx.dataPath = path.join(ctx.storageRoot, 'data', ctx.loaded.config.storage.dataName);
+}
 /** For commands that control the sandbox from your PC: inside the sandbox they make no sense. */
 export function requireOnPc(what) {
     if (insideSandbox())
-        fail('You are inside the sandbox already, so "sandbox ' + what + '" has nothing to control.', 'Run it from a terminal on your PC.');
+        fail('You are inside the sandbox already, so "sandbox ' + what + '" has nothing to control.', 'Run it from a terminal on your PC. Inside the sandbox these work: sandbox status, sessions, config, data, db, doctor, logs.');
 }
 export function requireRunning(hint = '') {
     if (!isSandboxRunning())
-        fail('No Windows Sandbox is running.', hint || 'Start one with sandbox claude.');
+        fail('No Windows Sandbox is running.', hint || 'Start one: sandbox start (no agent) or sandbox claude.');
 }
 /**
  * Maps a folder on this PC to its path inside the running sandbox (only folders inside the mapped workspace exist

package/dist/cli/commands/data/clean.d.ts

@@ -1,15 +1,3 @@
 import { type Context } from '../context.js';
-export interface CleanTarget {
-    /** The target as normalised (forward slashes), e.g. "tools/go". */
-    target: string;
-    path: string;
-    /** Folder the target must stay inside, with no links between the two. */
-    root: string;
-    warning?: string;
-}
-/**
- * Turns `sandbox data clean` arguments into folders. Pure (no disk access); throws a UserError for anything that is
- * not a plain relative target inside the data folder: absolute paths, drive letters, `..`, wildcards, unknown areas.
- */
-export declare function resolveCleanTargets(inputs: string[], dataPath: string, storageRoot: string): CleanTarget[];
+export { resolveCleanTargets, type CleanTarget } from '../../services/index.js';
 export declare function dataClean(ctx: Context): Promise<number>;