@wavexzore/sandbox 0.1.0

package/dist/sandbox/cli/opencode-config.js

@@ -0,0 +1,240 @@
+import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { HOST_CONFIG_SCHEMA_URL, WAVEXZORE_SANDBOX_PACKAGE, } from './types.js';
+import { statusForText, writeFileAtomic } from './local-store.js';
+function stripJsonComments(raw) {
+    let result = '';
+    let inString = false;
+    let stringChar = '';
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < raw.length; index += 1) {
+        const char = raw[index];
+        const next = raw[index + 1];
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === stringChar) {
+                inString = false;
+                stringChar = '';
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+            result += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+export function readOpenCodeConfig(configPath) {
+    if (!existsSync(configPath))
+        return {};
+    const raw = readFileSync(configPath, 'utf8');
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return JSON.parse(stripJsonComments(raw).replace(/,\s*([}\]])/g, '$1'));
+    }
+}
+function pluginSpec(item) {
+    if (typeof item === 'string') {
+        const spec = item.trim();
+        return spec.length > 0 ? spec : undefined;
+    }
+    if (Array.isArray(item) && typeof item[0] === 'string') {
+        const spec = item[0].trim();
+        return spec.length > 0 ? spec : undefined;
+    }
+    if (item && typeof item === 'object' && typeof item.name === 'string') {
+        const spec = item.name.trim();
+        return spec.length > 0 ? spec : undefined;
+    }
+    return undefined;
+}
+export function normalizePluginEntries(value) {
+    if (Array.isArray(value))
+        return [...value];
+    if (typeof value === 'string' && value.trim().length > 0)
+        return [value.trim()];
+    return [];
+}
+function normalizeSpec(spec) {
+    return spec.trim().replace(/^npm:/, '').replace(/\/+$/, '');
+}
+function isPackageSpec(normalized, packageName) {
+    return normalized === packageName || normalized.startsWith(`${packageName}@`);
+}
+function normalizeUrlPath(value) {
+    return value.replace(/\\/g, '/').replace(/\/+$/, '');
+}
+function isKnownFileSpec(spec) {
+    const normalizedSpec = normalizeUrlPath(spec);
+    let path = normalizedSpec;
+    if (spec.startsWith('file://')) {
+        try {
+            path = normalizeUrlPath(fileURLToPath(spec));
+        }
+        catch {
+            // Leave the original spec text in place when file URL decoding fails.
+        }
+    }
+    return (path.endsWith('/.wavexzore/opencode/sandbox/opencode-plugin') ||
+        path.includes('/.wavexzore/opencode/sandbox/opencode-plugin') ||
+        path.includes('/node_modules/@wavexzore/sandbox'));
+}
+export function isKnownWavexzoreSandboxPluginEntry(spec) {
+    const normalized = normalizeSpec(spec);
+    if (isPackageSpec(normalized, WAVEXZORE_SANDBOX_PACKAGE))
+        return true;
+    if (normalized === 'wavexzore-sandbox')
+        return true;
+    return isKnownFileSpec(spec);
+}
+export function nextPluginEntries(current, pluginEntry) {
+    const plugins = [];
+    const removed = [];
+    let alreadyInstalled = false;
+    for (const item of current) {
+        const spec = pluginSpec(item);
+        if (!spec) {
+            plugins.push(item);
+            continue;
+        }
+        if (spec === pluginEntry) {
+            if (!alreadyInstalled) {
+                plugins.push(item);
+                alreadyInstalled = true;
+            }
+            else {
+                removed.push(spec);
+            }
+            continue;
+        }
+        if (isKnownWavexzoreSandboxPluginEntry(spec)) {
+            removed.push(spec);
+            continue;
+        }
+        plugins.push(item);
+    }
+    if (!alreadyInstalled)
+        plugins.push(pluginEntry);
+    const same = JSON.stringify(current) === JSON.stringify(plugins);
+    return {
+        plugins,
+        removed,
+        pluginStatus: current.length === 0 && !alreadyInstalled ? 'created' : same ? 'existing' : 'updated',
+    };
+}
+export function installOpenCodeConfig(args) {
+    const existed = existsSync(args.configPath);
+    const current = readOpenCodeConfig(args.configPath);
+    const next = { ...current };
+    if (typeof next.$schema !== 'string' || next.$schema.length === 0)
+        next.$schema = HOST_CONFIG_SCHEMA_URL;
+    const pluginUpdate = nextPluginEntries(normalizePluginEntries(current.plugin), args.pluginEntry);
+    next.plugin = pluginUpdate.plugins;
+    const desired = `${JSON.stringify(next, null, 2)}\n`;
+    const configStatus = statusForText(args.configPath, desired);
+    if (!args.dryRun)
+        writeFileAtomic(args.configPath, desired);
+    return {
+        configPath: args.configPath,
+        configStatus: !existed ? 'created' : configStatus,
+        pluginEntry: args.pluginEntry,
+        pluginStatus: pluginUpdate.pluginStatus,
+        removedPluginEntries: pluginUpdate.removed,
+    };
+}
+function combineConfigStatus(removedPluginEntries, changed, exists, keepConfig) {
+    if (keepConfig)
+        return 'kept';
+    if (!exists)
+        return 'missing';
+    if (removedPluginEntries.length === 0)
+        return 'unchanged';
+    return changed ? 'updated' : 'unchanged';
+}
+export function uninstallOpenCodeConfig(args) {
+    if (args.keepConfig) {
+        return {
+            configPath: args.configPath,
+            configStatus: 'kept',
+            pluginEntry: args.pluginEntry,
+            removedPluginEntries: [],
+        };
+    }
+    if (!existsSync(args.configPath)) {
+        return {
+            configPath: args.configPath,
+            configStatus: 'missing',
+            pluginEntry: args.pluginEntry,
+            removedPluginEntries: [],
+        };
+    }
+    const current = readOpenCodeConfig(args.configPath);
+    const next = { ...current };
+    const removedPluginEntries = [];
+    const nextPlugins = [];
+    for (const item of normalizePluginEntries(current.plugin)) {
+        const spec = pluginSpec(item);
+        if (spec && (spec === args.pluginEntry || isKnownWavexzoreSandboxPluginEntry(spec))) {
+            removedPluginEntries.push(spec);
+            continue;
+        }
+        nextPlugins.push(item);
+    }
+    if (removedPluginEntries.length > 0) {
+        if (nextPlugins.length > 0)
+            next.plugin = nextPlugins;
+        else
+            delete next.plugin;
+    }
+    const desired = `${JSON.stringify(next, null, 2)}\n`;
+    const currentRaw = readFileSync(args.configPath, 'utf8');
+    const changed = desired !== currentRaw;
+    if (!args.dryRun && changed && removedPluginEntries.length > 0)
+        writeFileAtomic(args.configPath, desired);
+    return {
+        configPath: args.configPath,
+        configStatus: combineConfigStatus(removedPluginEntries, changed, true, args.keepConfig),
+        pluginEntry: args.pluginEntry,
+        removedPluginEntries,
+    };
+}

package/dist/sandbox/cli/path.d.ts

@@ -0,0 +1,64 @@
+import type { RuntimeEnv, StoreScope } from './types.js';
+export declare function runtimeEnv(env?: RuntimeEnv): RuntimeEnv;
+export declare function runtimePlatform(platform?: string): string;
+export declare function runtimeCwd(): string;
+export declare function defaultHome(env?: RuntimeEnv, platform?: string): string;
+export declare function resolveWavexzoreSandboxHomeDir(args?: {
+    root?: string;
+    scope?: StoreScope;
+    homeDir?: string;
+    storeDir?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string;
+export declare function resolveWavexzoreSandboxStoreDir(args?: {
+    root?: string;
+    scope?: StoreScope;
+    homeDir?: string;
+    storeDir?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string;
+export declare function resolveWavexzoreSandboxBinDir(args?: {
+    root?: string;
+    scope?: StoreScope;
+    homeDir?: string;
+    storeDir?: string;
+    binDir?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string;
+export declare function resolveOpenCodeConfigDir(args?: {
+    configDir?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string;
+export declare function resolveOpenCodeGlobalConfigCandidates(args?: {
+    configDir?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string[];
+export declare function resolveOpenCodeProjectConfigCandidates(args?: {
+    root?: string;
+    platform?: string;
+}): string[];
+export declare function resolveOpenCodeConfigPath(args?: {
+    root?: string;
+    scope?: StoreScope;
+    configDir?: string;
+    configPath?: string;
+    env?: RuntimeEnv;
+    platform?: string;
+}): string;
+export declare function pathSeparatorForPlatform(platform?: string): string;
+export declare function normalizePathForCompare(input: string, platform?: string): string;
+export declare function isDirectoryOnPath(binDir: string, envPath?: string, platform?: string): boolean;
+export declare function shellQuote(value: string): string;
+export declare function powershellSingleQuote(value: string): string;
+export declare function pathHintForPlatform(binDir: string, platform?: string): string;
+export declare function shellProfilePath(args: {
+    homeDir: string;
+    pathConfigPath?: string;
+    shell?: string;
+    env?: RuntimeEnv;
+}): string;

package/dist/sandbox/cli/path.js

@@ -0,0 +1,127 @@
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { basename, join, win32, posix } from 'path';
+const OPENCODE_GLOBAL_CONFIG_FILES = ['opencode.jsonc', 'opencode.json', 'config.json'];
+const OPENCODE_PROJECT_CONFIG_FILES = ['opencode.jsonc', 'opencode.json'];
+export function runtimeEnv(env) {
+    return env ?? process.env;
+}
+export function runtimePlatform(platform) {
+    return platform ?? process.platform;
+}
+export function runtimeCwd() {
+    return process.cwd();
+}
+function pathForPlatform(platform = runtimePlatform()) {
+    return platform === 'win32' ? win32 : posix;
+}
+export function defaultHome(env, platform = runtimePlatform()) {
+    const current = runtimeEnv(env);
+    if (platform === 'win32')
+        return current.USERPROFILE || current.HOME || homedir();
+    return current.HOME || current.USERPROFILE || homedir();
+}
+export function resolveWavexzoreSandboxHomeDir(args = {}) {
+    if (args.homeDir)
+        return args.homeDir;
+    const pathImpl = pathForPlatform(args.platform);
+    if (args.storeDir)
+        return pathImpl.dirname(args.storeDir);
+    const env = runtimeEnv(args.env);
+    const envHome = env.WAVEXZORE_SANDBOX_HOME || env.WAVEXZORE_SANDBOX_OPENCODE_HOME;
+    if (envHome)
+        return envHome;
+    if (args.scope === 'project')
+        return pathImpl.join(pathImpl.resolve(args.root ?? runtimeCwd()), '.wavexzore', 'opencode');
+    return pathImpl.join(defaultHome(env, args.platform), '.wavexzore', 'opencode');
+}
+export function resolveWavexzoreSandboxStoreDir(args = {}) {
+    if (args.storeDir)
+        return args.storeDir;
+    return pathForPlatform(args.platform).join(resolveWavexzoreSandboxHomeDir(args), 'sandbox');
+}
+export function resolveWavexzoreSandboxBinDir(args = {}) {
+    if (args.binDir)
+        return args.binDir;
+    return pathForPlatform(args.platform).join(resolveWavexzoreSandboxHomeDir(args), 'bin');
+}
+export function resolveOpenCodeConfigDir(args = {}) {
+    if (args.configDir)
+        return args.configDir;
+    const env = runtimeEnv(args.env);
+    const pathImpl = pathForPlatform(args.platform);
+    const configHome = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0
+        ? env.XDG_CONFIG_HOME
+        : pathImpl.join(defaultHome(env, args.platform), '.config');
+    return pathImpl.join(configHome, 'opencode');
+}
+function firstExistingOrDefault(candidates) {
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return candidates[0] ?? '';
+}
+export function resolveOpenCodeGlobalConfigCandidates(args = {}) {
+    const pathImpl = pathForPlatform(args.platform);
+    const dir = resolveOpenCodeConfigDir(args);
+    return OPENCODE_GLOBAL_CONFIG_FILES.map((file) => pathImpl.join(dir, file));
+}
+export function resolveOpenCodeProjectConfigCandidates(args = {}) {
+    const pathImpl = pathForPlatform(args.platform);
+    const root = pathImpl.resolve(args.root ?? runtimeCwd());
+    return [
+        ...OPENCODE_PROJECT_CONFIG_FILES.map((file) => pathImpl.join(root, file)),
+        ...OPENCODE_PROJECT_CONFIG_FILES.map((file) => pathImpl.join(root, '.opencode', file)),
+    ];
+}
+export function resolveOpenCodeConfigPath(args = {}) {
+    if (args.configPath)
+        return args.configPath;
+    const env = runtimeEnv(args.env);
+    if (args.scope !== 'project' && env.OPENCODE_CONFIG && env.OPENCODE_CONFIG.length > 0)
+        return env.OPENCODE_CONFIG;
+    if (args.scope === 'project') {
+        return firstExistingOrDefault(resolveOpenCodeProjectConfigCandidates(args));
+    }
+    return firstExistingOrDefault(resolveOpenCodeGlobalConfigCandidates(args));
+}
+export function pathSeparatorForPlatform(platform = runtimePlatform()) {
+    return platform === 'win32' ? ';' : ':';
+}
+export function normalizePathForCompare(input, platform = runtimePlatform()) {
+    const normalized = pathForPlatform(platform).resolve(input).replace(/[\\/]+$/, '');
+    return platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+export function isDirectoryOnPath(binDir, envPath = runtimeEnv().PATH ?? runtimeEnv().Path ?? '', platform = runtimePlatform()) {
+    const expected = normalizePathForCompare(binDir, platform);
+    return envPath
+        .split(pathSeparatorForPlatform(platform))
+        .filter((item) => item.trim().length > 0)
+        .some((item) => normalizePathForCompare(item.trim(), platform) === expected);
+}
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+export function powershellSingleQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function pathHintForPlatform(binDir, platform = runtimePlatform()) {
+    if (platform === 'win32') {
+        return `[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";${binDir}", "User")`;
+    }
+    return `export PATH=${shellQuote(binDir)}:"$PATH"`;
+}
+export function shellProfilePath(args) {
+    if (args.pathConfigPath)
+        return args.pathConfigPath;
+    const shell = args.shell ?? runtimeEnv(args.env).SHELL ?? '';
+    const shellName = basename(shell);
+    if (shellName === 'zsh')
+        return join(args.homeDir, '.zshrc');
+    if (shellName === 'fish')
+        return join(args.homeDir, '.config', 'fish', 'config.fish');
+    if (shellName === 'bash')
+        return join(args.homeDir, '.bashrc');
+    return join(args.homeDir, '.profile');
+}

package/dist/sandbox/cli/types.d.ts

@@ -0,0 +1,145 @@
+export declare const WAVEXZORE_SANDBOX_PACKAGE = "@wavexzore/sandbox";
+export declare const WAVEXZORE_SANDBOX_PLUGIN_ID = "wavexzore-sandbox";
+export declare const WAVEXZORE_SANDBOX_CLI = "wavexzore-sandbox";
+export declare const OPENCODE_HELPER_CLI = "wavexzore-sandbox-helper";
+export declare const WAVEXZORE_SANDBOX_LOADER_PACKAGE = "wavexzore-sandbox-local-loader";
+export declare const HOST_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+export type InstallStatus = 'created' | 'existing' | 'updated';
+export type BinStatus = InstallStatus | 'skipped';
+export type UninstallStatus = 'removed' | 'updated' | 'missing' | 'kept' | 'skipped' | 'unchanged';
+export type PathStatus = 'present' | 'missing' | 'updated' | 'removed' | 'skipped' | 'unchanged' | 'kept';
+export type StoreScope = 'user' | 'project';
+export type DoctorStatus = 'passed' | 'failed';
+export type RuntimeEnv = Record<string, string | undefined>;
+export type BaseOptions = {
+    root?: string;
+    scope?: StoreScope;
+    homeDir?: string;
+    storeDir?: string;
+    binDir?: string;
+    configDir?: string;
+    configPath?: string;
+    dryRun?: boolean;
+    env?: RuntimeEnv;
+    platform?: string;
+};
+export type WavexzoreSandboxManifest = {
+    schemaVersion: 1;
+    pluginId: typeof WAVEXZORE_SANDBOX_PLUGIN_ID;
+    packageName: typeof WAVEXZORE_SANDBOX_PACKAGE;
+    activeVersion: string;
+    installedVersions: string[];
+    channel: string;
+    installedAt: string;
+    updatedAt: string;
+    opencodeConfigPath: string;
+    opencodePluginSpec: string;
+    cliPath: string;
+};
+export type HostConfigResult = {
+    configPath: string;
+    configStatus: InstallStatus;
+    pluginEntry: string;
+    pluginStatus: InstallStatus;
+    removedPluginEntries: string[];
+};
+export type HostConfigUninstallResult = {
+    configPath: string;
+    configStatus: UninstallStatus;
+    pluginEntry: string;
+    removedPluginEntries: string[];
+};
+export type WavexzoreSandboxInstallOptions = BaseOptions & {
+    packageRoot?: string;
+    installBin?: boolean;
+    setupPath?: boolean;
+    noPathHint?: boolean;
+    pathConfigPath?: string;
+    envPath?: string;
+    shell?: string;
+    channel?: string;
+};
+export type WavexzoreSandboxInstallResult = {
+    root: string;
+    dryRun: boolean;
+    scope: StoreScope;
+    homeDir: string;
+    storeDir: string;
+    binDir: string;
+    cliPath: string;
+    binStatus: BinStatus;
+    pathStatus: PathStatus;
+    pathConfigPath?: string;
+    pathHint: string;
+    manifestPath: string;
+    manifestStatus: InstallStatus;
+    loaderDir: string;
+    loaderStatus: InstallStatus;
+    activeVersion: string;
+    versionPath: string;
+    versionStatus: InstallStatus;
+    configPath: string;
+    configStatus: InstallStatus;
+    pluginStatus: InstallStatus;
+    removedPluginEntries: string[];
+    pluginEntry: string;
+};
+export type WavexzoreSandboxUninstallOptions = BaseOptions & {
+    keepConfig?: boolean;
+    keepStore?: boolean;
+    keepBin?: boolean;
+    removePath?: boolean;
+    pathConfigPath?: string;
+    envPath?: string;
+    shell?: string;
+};
+export type WavexzoreSandboxUninstallResult = {
+    root: string;
+    dryRun: boolean;
+    scope: StoreScope;
+    homeDir: string;
+    storeDir: string;
+    binDir: string;
+    binStatus: UninstallStatus;
+    pathStatus: PathStatus;
+    pathConfigPath?: string;
+    storeStatus: UninstallStatus;
+    manifestPath: string;
+    configPath: string;
+    configStatus: UninstallStatus;
+    pluginEntry: string;
+    removedPluginEntries: string[];
+};
+export type DoctorCheck = {
+    name: string;
+    status: DoctorStatus;
+    message: string;
+    path?: string;
+};
+export type WavexzoreSandboxDoctorOptions = Omit<BaseOptions, 'dryRun'> & {
+    projectRoot?: string;
+    envPath?: string;
+};
+export type WavexzoreSandboxDoctorResult = {
+    status: DoctorStatus;
+    homeDir: string;
+    storeDir: string;
+    binDir: string;
+    cliPath: string;
+    configPath: string;
+    pluginEntry: string;
+    activeVersion?: string;
+    checks: DoctorCheck[];
+};
+export type WavexzoreSandboxPathOptions = BaseOptions & {
+    pathConfigPath?: string;
+    envPath?: string;
+    shell?: string;
+};
+export type WavexzoreSandboxPathResult = {
+    homeDir: string;
+    binDir: string;
+    pathStatus: PathStatus;
+    pathConfigPath?: string;
+    pathHint: string;
+};

package/dist/sandbox/cli/types.js

@@ -0,0 +1,6 @@
+export const WAVEXZORE_SANDBOX_PACKAGE = '@wavexzore/sandbox';
+export const WAVEXZORE_SANDBOX_PLUGIN_ID = 'wavexzore-sandbox';
+export const WAVEXZORE_SANDBOX_CLI = 'wavexzore-sandbox';
+export const OPENCODE_HELPER_CLI = 'wavexzore-sandbox-helper';
+export const WAVEXZORE_SANDBOX_LOADER_PACKAGE = 'wavexzore-sandbox-local-loader';
+export const HOST_CONFIG_SCHEMA_URL = 'https://opencode.ai/config.json';

package/dist/sandbox/cli/wavexzore-sandbox.d.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import type { StoreScope } from './types.js';
+type StreamWriter = {
+    write: (chunk: string) => unknown;
+};
+type CliOptions = {
+    cwd?: string;
+    stdout?: StreamWriter;
+    stderr?: StreamWriter;
+};
+type BaseArgs = {
+    root: string;
+    configDir?: string;
+    configPath?: string;
+    homeDir?: string;
+    binDir?: string;
+    storeDir?: string;
+    scope: StoreScope;
+    json: boolean;
+    dryRun: boolean;
+    help: boolean;
+    error?: string;
+};
+type InstallArgs = BaseArgs & {
+    noBin: boolean;
+    setupPath: boolean;
+    noPathHint: boolean;
+    packageRoot?: string;
+};
+type UninstallArgs = BaseArgs & {
+    keepConfig: boolean;
+    keepStore: boolean;
+    keepBin: boolean;
+    removePath: boolean;
+};
+type DoctorArgs = {
+    homeDir?: string;
+    binDir?: string;
+    storeDir?: string;
+    configDir?: string;
+    configPath?: string;
+    projectRoot?: string;
+    scope: StoreScope;
+    json: boolean;
+    help: boolean;
+    error?: string;
+};
+type SetupPathArgs = {
+    homeDir?: string;
+    binDir?: string;
+    storeDir?: string;
+    scope: StoreScope;
+    json: boolean;
+    dryRun: boolean;
+    help: boolean;
+    error?: string;
+};
+export declare const WAVEXZORE_SANDBOX_CLI_HELP = "wavexzore-sandbox CLI\n\nUsage:\n  wavexzore-sandbox install [path] [--root <path>] [--scope <user|project>] [--home-dir <path>] [--store-dir <path>] [--bin-dir <path>] [--config-path <file>] [--config-dir <path>] [--package-root <path>] [--json] [--dry-run] [--no-bin] [--setup-path]\n  wavexzore-sandbox uninstall [path] [--root <path>] [--scope <user|project>] [--home-dir <path>] [--store-dir <path>] [--bin-dir <path>] [--config-path <file>] [--config-dir <path>] [--json] [--dry-run] [--keep-config] [--keep-store] [--keep-bin] [--remove-path]\n  wavexzore-sandbox doctor [--scope <user|project>] [--home-dir <path>] [--store-dir <path>] [--bin-dir <path>] [--config-path <file>] [--config-dir <path>] [--project-root <path>] [--json]\n  wavexzore-sandbox setup-path [--scope <user|project>] [--home-dir <path>] [--store-dir <path>] [--bin-dir <path>] [--json] [--dry-run]\n  wavexzore-sandbox help\n\nCommands:\n  install       Deploy @wavexzore/sandbox into a durable local store and configure OpenCode with a file:// plugin loader\n  uninstall     Remove Wavexzore Sandbox from OpenCode config and delete the local store by default\n  doctor        Validate OpenCode config, local loader, manifest, active version, plugin import, and OpenCode helper\n  setup-path    Explicitly add the Wavexzore Sandbox bin directory to PATH/profile\n  help          Show this help message\n\nOptions:\n  --root <path>         Invocation workspace. Used for --scope project and relative paths.\n  --scope <value>       user (default) or project. Project scope writes <root>/.wavexzore/opencode/sandbox.\n  --home-dir <path>     Product home. Default: ~/.wavexzore/opencode or WAVEXZORE_SANDBOX_HOME.\n  --store-dir <path>    Explicit local store directory. Default: ~/.wavexzore/opencode/sandbox.\n  --bin-dir <path>      Internal helper directory. Default: ~/.wavexzore/opencode/bin.\n  --config-path <file>  Exact OpenCode config file. Otherwise honors OPENCODE_CONFIG for user scope.\n  --config-dir <path>   OpenCode config directory for user scope.\n  --package-root <path> Install only: package root override for development/testing.\n  --no-bin              Install only: do not create or repair the internal helper/shims under --bin-dir.\n  --setup-path          Install only: explicitly add --bin-dir to PATH/profile.\n  --no-path-hint        Install only: suppress PATH hint output after an explicit --setup-path attempt.\n  --dry-run             Report changes without writing files where supported.\n  --keep-config         Uninstall only: keep OpenCode config unchanged.\n  --keep-store          Uninstall only: keep ~/.wavexzore/opencode/sandbox or --store-dir.\n  --keep-bin            Uninstall only: keep ~/.wavexzore/opencode/bin helper/shims or --bin-dir.\n  --remove-path         Uninstall only: remove the managed PATH/profile marker or Windows user Path entry.\n  --json                Print machine-readable output.\n  -h, --help            Show command help.\n";
+export declare function parseInstallArgs(args: string[]): InstallArgs;
+export declare function parseUninstallArgs(args: string[]): UninstallArgs;
+export declare function parseDoctorArgs(args: string[]): DoctorArgs;
+export declare function parseSetupPathArgs(args: string[]): SetupPathArgs;
+export declare function runWavexzoreSandboxCli(argv: string[], options?: CliOptions): Promise<number>;
+export declare function isMainModule(metaUrl?: string, argv1?: string): boolean;
+export {};