@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/commands/role-groups.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { RevoClient } from "../client.js";
+import { resolveProjectRoot, readProjectStableKeyName } from "../project.js";
+import { buildRoleGroupsPlan, pullRoleGroupsToWorkspace, pushRoleGroups } from "../resource-syncs/role-group-sync.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+function requireEnvName(context) {
+    const envName = readFlag(context.args, ['env']);
+    if (!envName)
+        throw new Error('Missing --project <name>.');
+    return envName;
+}
+function environmentClient(envName) {
+    return new RevoClient({ envName });
+}
+function warnAboutExperimentalState(context) {
+    const projectRoot = resolveProjectRoot(context.cwd) || path.resolve(context.cwd);
+    const legacyPaths = [
+        path.join(projectRoot, '.revoengine', 'resources'),
+        path.join(projectRoot, '.revoengine', 'resources.lock.json'),
+        path.join(projectRoot, '.revoengine', 'plans'),
+    ].filter((candidate) => fs.existsSync(candidate));
+    if (legacyPaths.length > 0) {
+        const warning = `Ignoring experimental ${legacyPaths.map((candidate) => path.relative(projectRoot, candidate)).join(', ')}; role-groups use workspace/RoleGroups and .revoengine/revo.lock.json.`;
+        if (readBoolFlag(context.args, ['json']))
+            (context.warn || context.error)(warning);
+        else
+            context.println(warning);
+    }
+}
+async function handlePull(context) {
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Role-group pull currently requires --all.');
+    }
+    const envName = requireEnvName(context);
+    const startedAt = Date.now();
+    const result = await pullRoleGroupsToWorkspace({
+        client: environmentClient(envName),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+        return;
+    }
+    const outputResults = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        outputResults.push({ status: 'pulled', targetPath: pulled.targetPath });
+    }
+    for (const skipped of result.skipped) {
+        printSyncStatus(context.println, { status: 'Skipped', direction: 'pull', targetPath: skipped.targetPath, reason: skipped.reason });
+        outputResults.push({ status: 'skipped', targetPath: skipped.targetPath, reason: skipped.reason });
+    }
+    printSyncSummary(context.println, 'Pulled', outputResults, Date.now() - startedAt);
+}
+async function handlePlan(context) {
+    if (!readBoolFlag(context.args, ['all', 'a']))
+        throw new Error('Role-group plan currently requires --all.');
+    if (readBoolFlag(context.args, ['prune'])) {
+        throw new Error('Role-group prune is disabled until the backend soft-delete contract is confirmed.');
+    }
+    const envName = requireEnvName(context);
+    const plan = await buildRoleGroupsPlan({
+        client: environmentClient(envName),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+    });
+    if (readBoolFlag(context.args, ['json']))
+        context.print(plan);
+    else
+        printSyncPlan(context.println, {
+            title: 'Role-group',
+            environment: plan.env,
+            counts: plan.counts,
+            items: plan.items.map((item) => ({
+                ...item,
+                details: [
+                    ...(item.rolesToAdd?.length ? [{ label: 'roles add', values: item.rolesToAdd }] : []),
+                    ...(item.rolesToRemove?.length ? [{ label: 'roles remove', values: item.rolesToRemove }] : []),
+                ],
+            })),
+            blockers: plan.blockers,
+        });
+    if (readBoolFlag(context.args, ['strict'])) {
+        const drift = plan.items.filter((item) => !['clean', 'orphan', 'skipped'].includes(item.status));
+        if (plan.blockers.length > 0 || drift.length > 0) {
+            throw new Error(`Role-group plan is not clean: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s).`);
+        }
+    }
+}
+async function handlePush(context) {
+    if (!readBoolFlag(context.args, ['all', 'a']))
+        throw new Error('Role-group push currently requires --all.');
+    if (readBoolFlag(context.args, ['prune'])) {
+        throw new Error('Role-group prune is disabled until the backend soft-delete contract is confirmed.');
+    }
+    const envName = requireEnvName(context);
+    if (!readBoolFlag(context.args, ['yes', 'y'])) {
+        if (!isInteractiveTerminal() || !await promptConfirm(`Push role-groups to "${envName}"?`, false)) {
+            throw new Error('Role-group push requires confirmation. Re-run with --yes or use an interactive terminal.');
+        }
+    }
+    const startedAt = Date.now();
+    const result = await pushRoleGroups({
+        client: environmentClient(envName),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+    }
+    else {
+        for (const item of result.results) {
+            const label = item.status === 'deployed' ? 'Deployed' : item.status === 'failed' ? 'Failed' : 'Skipped';
+            printSyncStatus(context.println, {
+                status: label,
+                direction: 'push',
+                targetPath: item.targetPath,
+                reason: item.error || item.reason,
+            });
+        }
+        printSyncSummary(context.println, 'Deployed', result.results, Date.now() - startedAt);
+    }
+    const failed = result.results.filter((item) => item.status === 'failed');
+    if (failed.length > 0)
+        throw new Error(`Role-group push finished with ${failed.length} failure(s).`);
+}
+export async function handleRoleGroupsCommand(context) {
+    warnAboutExperimentalState(context);
+    const subcommand = context.args._[1] || '';
+    if (subcommand === 'pull') {
+        await handlePull(context);
+        return;
+    }
+    if (subcommand === 'plan') {
+        await handlePlan(context);
+        return;
+    }
+    if (subcommand === 'push') {
+        await handlePush(context);
+        return;
+    }
+    throw new Error('Unknown role-groups command. Usage: revo role-groups <pull|plan|push> --all --project <name>');
+}

package/dist/src/commands/schedules.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../types.ts';
+export declare function handleSchedulesCommand(context: CommandContext): Promise<void>;

package/dist/src/commands/schedules.js

@@ -0,0 +1,141 @@
+import { RevoClient } from "../client.js";
+import { DEFAULT_ENV_NAME } from "../config.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { readProjectStableKeyName } from "../project.js";
+import { activateVerifiedSchedules, buildSchedulesPlan, pullSchedulesToWorkspace, pushSchedules } from "../resource-syncs/schedule-sync.js";
+import { printSyncNotice, printSyncPlan, printSyncStatus, printSyncSummary } from "../sync-output.js";
+import { readBoolFlag, readFlag } from "../utils.js";
+export async function handleSchedulesCommand(context) {
+    const subcommand = context.args._[1] || '';
+    if (!['pull', 'plan', 'push'].includes(subcommand)) {
+        throw new Error('Unknown schedules command. Usage: revo schedules <pull|plan|push> --all --project <name>');
+    }
+    if (!readBoolFlag(context.args, ['all', 'a'])) {
+        throw new Error('Schedule sync currently requires --all.');
+    }
+    const envName = readFlag(context.args, ['env']);
+    if (!envName) {
+        throw new Error('Missing --project <name>.');
+    }
+    if (envName === DEFAULT_ENV_NAME) {
+        throw new Error('Schedule sync requires a named environment profile; "default" is not supported.');
+    }
+    const activate = readBoolFlag(context.args, ['activate']);
+    if (activate && subcommand !== 'push') {
+        throw new Error('--activate is available only with schedules push.');
+    }
+    if (subcommand === 'push') {
+        const yes = readBoolFlag(context.args, ['yes', 'y']);
+        if (activate && !yes && !isInteractiveTerminal()) {
+            throw new Error('Schedule activation in non-interactive mode requires --yes --activate.');
+        }
+        if (!yes) {
+            if (!isInteractiveTerminal() || !await promptConfirm(`Push Schedules to "${envName}"?`, false)) {
+                throw new Error('Schedule push requires confirmation. Re-run with --yes or use an interactive terminal.');
+            }
+        }
+        const startedAt = Date.now();
+        const client = new RevoClient({ envName });
+        const pushed = await pushSchedules({
+            client,
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+            force: readBoolFlag(context.args, ['force', 'f']),
+            allowMaterialized: readBoolFlag(context.args, ['allow-materialized']),
+        });
+        const results = [...pushed.results];
+        let activation;
+        if (activate) {
+            const candidateCount = pushed.verifiedActivationCandidates.length;
+            const confirmed = !isInteractiveTerminal() || await promptConfirm(`Activate ${candidateCount} verified Schedule(s) on "${envName}"?`, false);
+            if (confirmed) {
+                const activationResults = await activateVerifiedSchedules({
+                    client,
+                    candidates: pushed.verifiedActivationCandidates,
+                });
+                results.push(...activationResults);
+                activation = { candidateCount, results: activationResults };
+            }
+            else {
+                activation = { candidateCount, results: [], skipped: 'activation not confirmed' };
+            }
+        }
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print({
+                plan: pushed.plan,
+                results,
+                ...(activation ? { activation } : {}),
+            });
+        }
+        else {
+            for (const item of results) {
+                const label = item.status === 'deployed' ? 'Deployed' : item.status === 'failed' ? 'Failed' : 'Skipped';
+                printSyncStatus(context.println, {
+                    status: label,
+                    direction: 'push',
+                    targetPath: item.targetPath,
+                    reason: item.error || item.reason,
+                });
+            }
+            if (activation?.skipped) {
+                printSyncNotice(context.println, `${activation.candidateCount} verified Schedule activation candidate(s): ${activation.skipped}`);
+            }
+            printSyncSummary(context.println, 'Deployed', results, Date.now() - startedAt);
+        }
+        const failed = results.filter((item) => item.status === 'failed');
+        if (failed.length > 0) {
+            throw new Error(`Schedule push finished with ${failed.length} failure(s).`);
+        }
+        return;
+    }
+    if (subcommand === 'plan') {
+        const plan = await buildSchedulesPlan({
+            client: new RevoClient({ envName }),
+            cwd: context.cwd,
+            envName,
+            stableKeyName: readProjectStableKeyName(context.cwd),
+        });
+        if (readBoolFlag(context.args, ['json'])) {
+            context.print(plan);
+        }
+        else {
+            printSyncPlan(context.println, {
+                title: 'Schedule',
+                environment: plan.env,
+                counts: plan.counts,
+                items: plan.items,
+                warnings: [...plan.warnings, ...plan.exclusions],
+                blockers: plan.blockers,
+            });
+        }
+        if (readBoolFlag(context.args, ['strict'])) {
+            const drift = plan.items.filter((item) => !['clean', 'orphan', 'skipped'].includes(item.status));
+            if (plan.blockers.length > 0 || plan.exclusions.length > 0 || drift.length > 0) {
+                throw new Error(`Schedule strict plan is not converged: ${drift.length} drift item(s), ${plan.blockers.length} blocker(s), ${plan.exclusions.length} exclusion(s).`);
+            }
+        }
+        return;
+    }
+    const startedAt = Date.now();
+    const result = await pullSchedulesToWorkspace({
+        client: new RevoClient({ envName }),
+        cwd: context.cwd,
+        envName,
+        stableKeyName: readProjectStableKeyName(context.cwd),
+        force: readBoolFlag(context.args, ['force', 'f']),
+    });
+    if (readBoolFlag(context.args, ['json'])) {
+        context.print(result);
+        return;
+    }
+    const output = [];
+    for (const pulled of result.pulled) {
+        printSyncStatus(context.println, { status: 'Pulled', direction: 'pull', targetPath: pulled.targetPath });
+        output.push({ status: 'pulled', targetPath: pulled.targetPath });
+    }
+    for (const warning of result.warnings) {
+        printSyncNotice(context.println, `${warning.stableKey}: ${warning.reason}`);
+    }
+    printSyncSummary(context.println, 'Pulled', output, Date.now() - startedAt);
+}

package/dist/src/commands/terminal-service.d.ts

@@ -0,0 +1,38 @@
+type Launchctl = (args: string[]) => void;
+type ServiceOptions = {
+    workspace: string;
+    envName?: string;
+    home?: string;
+    entrypoint?: string;
+    nodePath?: string;
+    pathValue?: string;
+    configHome?: string;
+    uid?: number;
+    platform?: NodeJS.Platform;
+    launchctl?: Launchctl;
+    systemctl?: (args: string[]) => void;
+};
+export declare function terminalServicePaths(workspace: string, envName?: string, home?: string): {
+    label: string;
+    plist: string;
+    logDirectory: string;
+    stdout: string;
+    stderr: string;
+};
+export declare function terminalSystemdPaths(workspace: string, envName?: string, home?: string, configHome?: string): {
+    label: string;
+    unit: string;
+};
+export declare function renderTerminalSystemdUnit(options: ServiceOptions): string;
+export declare function renderTerminalServicePlist(options: ServiceOptions): string;
+export declare function terminalServiceInstalled(workspace: string, envName?: string): boolean;
+export declare function installTerminalService(options: ServiceOptions): {
+    label: string;
+    serviceFile: string;
+    installed: boolean;
+};
+export declare function uninstallTerminalService(options: ServiceOptions): {
+    label: string;
+    removed: boolean;
+};
+export {};

package/dist/src/commands/terminal-service.js

@@ -0,0 +1,210 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+const AUTH_ENV_KEYS = ['REVO_TOKEN', 'REVO_API_KEY', 'REVOENGINE_TOKEN', 'REVOENGINE_API_KEY',
+    'REVO_URL', 'REVO_BASE_URL', 'REVOENGINE_URL', 'REVOENGINE_BASE_URL',
+    'REVO_INSTANCE', 'REVOENGINE_INSTANCE'];
+function xml(value) {
+    if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/u.test(value))
+        throw new Error('LaunchAgent value contains an invalid control character.');
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+export function terminalServicePaths(workspace, envName = 'default', home = os.homedir()) {
+    const hash = createHash('sha256').update(`${workspace}\0${envName}`).digest('hex').slice(0, 16);
+    const label = `com.revoengine.terminal.${hash}`;
+    return {
+        label,
+        plist: path.join(home, 'Library', 'LaunchAgents', `${label}.plist`),
+        logDirectory: path.join(home, 'Library', 'Logs', 'RevoEngine'),
+        stdout: path.join(home, 'Library', 'Logs', 'RevoEngine', `${label}.out.log`),
+        stderr: path.join(home, 'Library', 'Logs', 'RevoEngine', `${label}.err.log`),
+    };
+}
+export function terminalSystemdPaths(workspace, envName = 'default', home = os.homedir(), configHome = path.join(home, '.config')) {
+    if (!path.isAbsolute(configHome))
+        throw new Error('XDG_CONFIG_HOME must be an absolute path.');
+    const hash = createHash('sha256').update(`${workspace}\0${envName}`).digest('hex').slice(0, 16);
+    const label = `revo-terminal-${hash}.service`;
+    return { label, unit: path.join(configHome, 'systemd', 'user', label) };
+}
+function systemdQuote(value, execArgument = false) {
+    if (/[\u0000-\u001f\u007f]/u.test(value))
+        throw new Error('Systemd unit value contains an invalid control character.');
+    let escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%');
+    if (execArgument)
+        escaped = escaped.replace(/\$/g, '$$$$');
+    return `"${escaped}"`;
+}
+export function renderTerminalSystemdUnit(options) {
+    const node = options.nodePath || process.execPath;
+    const entrypoint = options.entrypoint || (process.argv[1] && fs.realpathSync(process.argv[1]));
+    if (!entrypoint || !path.isAbsolute(node) || !path.isAbsolute(entrypoint))
+        throw new Error('Cannot resolve absolute Node.js and revo executable paths for systemd.');
+    const args = [node, entrypoint, 'terminal', 'connect', '--workspace', options.workspace,
+        ...(options.envName && options.envName !== 'default' ? ['--env', options.envName] : [])];
+    const env = [
+        ...(options.pathValue ? [`Environment=${systemdQuote(`PATH=${options.pathValue}`)}`] : []),
+        ...(options.configHome ? [`Environment=${systemdQuote(`XDG_CONFIG_HOME=${options.configHome}`)}`] : []),
+    ];
+    return `[Unit]\nDescription=RevoEngine Agent Terminal\n\n[Service]\nType=simple\nExecStart=${args.map(arg => systemdQuote(arg, true)).join(' ')}\nRestart=always\nRestartSec=30s\n${env.join('\n')}${env.length ? '\n' : ''}UnsetEnvironment=${AUTH_ENV_KEYS.join(' ')}\n\n[Install]\nWantedBy=default.target\n`;
+}
+export function renderTerminalServicePlist(options) {
+    const paths = terminalServicePaths(options.workspace, options.envName, options.home);
+    const node = options.nodePath || process.execPath;
+    const entrypoint = options.entrypoint || (process.argv[1] && fs.realpathSync(process.argv[1]));
+    if (!entrypoint || !path.isAbsolute(node) || !path.isAbsolute(entrypoint))
+        throw new Error('Cannot resolve absolute Node.js and revo executable paths for LaunchAgent.');
+    const args = [node, entrypoint, 'terminal', 'connect', '--workspace', options.workspace,
+        ...(options.envName && options.envName !== 'default' ? ['--env', options.envName] : [])];
+    const lines = args.map(arg => `    <string>${xml(arg)}</string>`).join('\n');
+    const env = [];
+    if (options.pathValue)
+        env.push(`    <key>PATH</key><string>${xml(options.pathValue)}</string>`);
+    if (options.configHome)
+        env.push(`    <key>XDG_CONFIG_HOME</key><string>${xml(options.configHome)}</string>`);
+    for (const key of AUTH_ENV_KEYS)
+        env.push(`    <key>${key}</key><string></string>`);
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key><string>${xml(paths.label)}</string>\n  <key>ProgramArguments</key>\n  <array>\n${lines}\n  </array>\n  <key>RunAtLoad</key><true/>\n  <key>KeepAlive</key><true/>\n  <key>ThrottleInterval</key><integer>30</integer>\n  <key>StandardOutPath</key><string>${xml(paths.stdout)}</string>\n  <key>StandardErrorPath</key><string>${xml(paths.stderr)}</string>\n  <key>EnvironmentVariables</key>\n  <dict>\n${env.join('\n')}\n  </dict>\n</dict>\n</plist>\n`;
+}
+function ensureMac(options) {
+    if ((options.platform || process.platform) !== 'darwin')
+        throw new Error('Terminal background service currently supports macOS only.');
+    const uid = options.uid ?? process.getuid?.();
+    if (uid === undefined)
+        throw new Error('Cannot resolve the macOS user ID for LaunchAgent.');
+    return uid;
+}
+function ensureSupported(options) {
+    const platform = options.platform || process.platform;
+    if (platform !== 'darwin' && platform !== 'linux')
+        throw new Error('Terminal background service supports macOS and Linux only.');
+    return platform;
+}
+function systemctl(options, args) {
+    if (options.systemctl)
+        options.systemctl(args);
+    else
+        execFileSync('systemctl', ['--user', ...args], { stdio: 'pipe' });
+}
+function launchctl(options, args) {
+    if (options.launchctl)
+        options.launchctl(args);
+    else
+        execFileSync('/bin/launchctl', args, { stdio: 'pipe' });
+}
+function isLoaded(options, uid, label) {
+    try {
+        launchctl(options, ['print', `gui/${uid}/${label}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function terminalServiceInstalled(workspace, envName = 'default') {
+    if (process.platform === 'linux')
+        return fs.existsSync(terminalSystemdPaths(workspace, envName, os.homedir(), process.env.XDG_CONFIG_HOME).unit);
+    return fs.existsSync(terminalServicePaths(workspace, envName).plist);
+}
+function installLinuxTerminalService(options) {
+    const paths = terminalSystemdPaths(options.workspace, options.envName, options.home, options.configHome || path.join(options.home || os.homedir(), '.config'));
+    const content = renderTerminalSystemdUnit(options);
+    fs.mkdirSync(path.dirname(paths.unit), { recursive: true, mode: 0o700 });
+    if (fs.existsSync(paths.unit)) {
+        if (fs.readFileSync(paths.unit, 'utf8') !== content)
+            throw new Error('Terminal service configuration differs. Uninstall it before installing again.');
+        systemctl(options, ['enable', '--now', paths.label]);
+        return { label: paths.label, serviceFile: paths.unit, installed: false };
+    }
+    const temporary = `${paths.unit}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, content, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporary, paths.unit);
+        try {
+            systemctl(options, ['daemon-reload']);
+            systemctl(options, ['enable', '--now', paths.label]);
+        }
+        catch (error) {
+            try {
+                systemctl(options, ['disable', '--now', paths.label]);
+            }
+            catch { /* best effort rollback */ }
+            fs.unlinkSync(paths.unit);
+            try {
+                systemctl(options, ['daemon-reload']);
+            }
+            catch { /* original failure is primary */ }
+            throw error;
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return { label: paths.label, serviceFile: paths.unit, installed: true };
+}
+export function installTerminalService(options) {
+    if (ensureSupported(options) === 'linux')
+        return installLinuxTerminalService(options);
+    const uid = ensureMac(options);
+    const paths = terminalServicePaths(options.workspace, options.envName, options.home);
+    const content = renderTerminalServicePlist(options);
+    fs.mkdirSync(path.dirname(paths.plist), { recursive: true, mode: 0o700 });
+    fs.mkdirSync(paths.logDirectory, { recursive: true, mode: 0o700 });
+    if (fs.existsSync(paths.plist)) {
+        if (fs.readFileSync(paths.plist, 'utf8') !== content)
+            throw new Error('Terminal service configuration differs. Uninstall it before installing again.');
+        if (!isLoaded(options, uid, paths.label))
+            launchctl(options, ['bootstrap', `gui/${uid}`, paths.plist]);
+        return { label: paths.label, serviceFile: paths.plist, installed: false };
+    }
+    const temporary = `${paths.plist}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, content, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporary, paths.plist);
+        try {
+            launchctl(options, ['bootstrap', `gui/${uid}`, paths.plist]);
+        }
+        catch (error) {
+            fs.unlinkSync(paths.plist);
+            throw error;
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return { label: paths.label, serviceFile: paths.plist, installed: true };
+}
+export function uninstallTerminalService(options) {
+    if (ensureSupported(options) === 'linux') {
+        const paths = terminalSystemdPaths(options.workspace, options.envName, options.home, options.configHome || path.join(options.home || os.homedir(), '.config'));
+        if (!fs.existsSync(paths.unit))
+            return { label: paths.label, removed: false };
+        systemctl(options, ['disable', '--now', paths.label]);
+        fs.unlinkSync(paths.unit);
+        systemctl(options, ['daemon-reload']);
+        return { label: paths.label, removed: true };
+    }
+    const uid = ensureMac(options);
+    const paths = terminalServicePaths(options.workspace, options.envName, options.home);
+    const exists = fs.existsSync(paths.plist);
+    if (isLoaded(options, uid, paths.label))
+        launchctl(options, ['bootout', `gui/${uid}/${paths.label}`]);
+    if (exists)
+        fs.unlinkSync(paths.plist);
+    return { label: paths.label, removed: exists };
+}

package/dist/src/commands/terminal.d.ts

@@ -0,0 +1,22 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function childEnvironment(source: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function resolveWorkspaceDirectory(root: string, requested: string): string;
+export declare function boundResultFrame(frame: Record<string, unknown>): Record<string, unknown>;
+export declare function runCommand(input: {
+    cmd: string;
+    workdir: string;
+    workspace: string;
+    timeoutMs: number;
+    executionId?: string;
+    logDir?: string;
+}, onDone: (result: {
+    executed: boolean;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    truncated: boolean;
+    logTruncated: boolean;
+    logPath: string;
+}) => void, onChunk?: (stream: 'stdout' | 'stderr', text: string) => void): Promise<ChildProcess>;
+export declare function handleTerminalCommand(argv: string[]): Promise<void>;