@fission-ai/openspec 1.4.1 → 1.6.0-beta.1

package/dist/commands/workspace/open-target-selection.js

@@ -1,146 +0,0 @@
-import { InitiativeResolutionError, initiativeDiagnosticFromError, listInitiativeViewReferences, } from '../../core/collections/initiatives/index.js';
-import { createRegisteredContextStoreBinding, sameContextStoreBinding, } from '../../core/context-store/index.js';
-import { findWorkspaceRoot, getWorkspaceContextInitiativeId, listKnownWorkspaceEntries, readWorkspaceViewState, } from '../../core/workspace/index.js';
-import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
-import { selectWorkspaceForCommand, selectedWorkspaceFromEntry, selectedWorkspaceFromRoot, } from './selection.js';
-import { WorkspaceCliError, } from './types.js';
-async function readKnownWorkspaceContexts(entries) {
-    return Promise.all(entries.map(async (entry) => {
-        try {
-            return (await readWorkspaceViewState(entry.workspaceRoot)).context;
-        }
-        catch {
-            // Broken workspaces are surfaced by list/doctor; open target selection
-            // should not hide otherwise openable initiatives behind unreadable views.
-            return null;
-        }
-    }));
-}
-function workspaceContextMatchesInitiative(context, initiative) {
-    return (context !== null &&
-        sameContextStoreBinding(context.store, createRegisteredContextStoreBinding(initiative.store)) &&
-        getWorkspaceContextInitiativeId(context) === initiative.id);
-}
-function initiativeHasKnownWorkspace(contexts, initiative) {
-    return contexts.some((context) => workspaceContextMatchesInitiative(context, initiative));
-}
-function initiativeDiagnosticToWorkspaceStatus(diagnostic) {
-    return {
-        severity: diagnostic.severity,
-        code: diagnostic.code,
-        message: diagnostic.message,
-        target: diagnostic.target,
-        fix: diagnostic.fix,
-        details: diagnostic.details,
-    };
-}
-async function listOpenableInitiatives(entries) {
-    try {
-        const [result, contexts] = await Promise.all([
-            listInitiativeViewReferences(),
-            readKnownWorkspaceContexts(entries),
-        ]);
-        const initiatives = [];
-        for (const initiative of result.initiatives) {
-            if (!initiativeHasKnownWorkspace(contexts, initiative)) {
-                initiatives.push(initiative);
-            }
-        }
-        return {
-            kind: 'listed',
-            initiatives,
-            status: result.status.map(initiativeDiagnosticToWorkspaceStatus),
-        };
-    }
-    catch (error) {
-        const diagnostic = error instanceof InitiativeResolutionError
-            ? initiativeDiagnosticFromError(error)
-            : {
-                severity: 'error',
-                code: 'initiative_discovery_failed',
-                message: error instanceof Error ? error.message : String(error),
-                target: 'initiative',
-                fix: 'openspec context-store doctor',
-            };
-        return {
-            kind: 'unavailable',
-            initiatives: [],
-            status: [initiativeDiagnosticToWorkspaceStatus(diagnostic)],
-            error: new WorkspaceCliError(diagnostic.message, diagnostic.code, {
-                target: diagnostic.target,
-                fix: diagnostic.fix,
-                details: diagnostic.details,
-            }),
-        };
-    }
-}
-export async function selectWorkspaceOpenTarget(workspaceName, options) {
-    if (workspaceName ||
-        options.json ||
-        resolveNoInteractive(options) ||
-        !isInteractive(options)) {
-        return {
-            kind: 'workspace',
-            selected: await selectWorkspaceForCommand({
-                ...options,
-                workspace: workspaceName,
-            }, 'open', { preferPositionalName: true }),
-            status: [],
-        };
-    }
-    const entries = await listKnownWorkspaceEntries();
-    const currentWorkspaceRoot = await findWorkspaceRoot(process.cwd());
-    if (currentWorkspaceRoot) {
-        return {
-            kind: 'workspace',
-            selected: await selectedWorkspaceFromRoot(currentWorkspaceRoot, entries),
-            status: [],
-        };
-    }
-    const listed = await listOpenableInitiatives(entries);
-    if (listed.initiatives.length === 0) {
-        if (listed.kind === 'unavailable' && entries.length === 0) {
-            throw listed.error;
-        }
-        return {
-            kind: 'workspace',
-            selected: await selectWorkspaceForCommand(options, 'open', {
-                preferPositionalName: true,
-            }),
-            status: listed.status,
-        };
-    }
-    const { select } = await import('@inquirer/prompts');
-    const selected = await select({
-        message: 'Select workspace or initiative:',
-        choices: [
-            ...entries.map((entry) => ({
-                name: `Workspace: ${entry.name} (${entry.workspaceRoot})`,
-                value: {
-                    kind: 'workspace',
-                    entry,
-                },
-            })),
-            ...listed.initiatives.map((initiative) => ({
-                name: `Initiative: ${initiative.store}/${initiative.id} - ${initiative.title} (create local workspace view)`,
-                value: {
-                    kind: 'initiative',
-                    initiative,
-                },
-            })),
-        ],
-    });
-    if (selected.kind === 'workspace') {
-        return {
-            kind: 'workspace',
-            selected: selectedWorkspaceFromEntry(selected.entry),
-            status: listed.status,
-        };
-    }
-    return {
-        kind: 'initiative',
-        initiative: selected.initiative,
-        status: listed.status,
-    };
-}
-//# sourceMappingURL=open-target-selection.js.map

package/dist/commands/workspace/open-view.d.ts

@@ -1,62 +0,0 @@
-import { InitiativeViewReference } from '../../core/collections/initiatives/index.js';
-import { type ContextStoreBinding } from '../../core/context-store/index.js';
-import { WorkspaceContextState, WorkspacePreferredOpener } from '../../core/workspace/index.js';
-import { type WorkspaceOpenCommandBuildResult } from './open.js';
-import { SelectedWorkspace, WorkspaceOpenOptions, WorkspaceStatus } from './types.js';
-export interface PreparedWorkspaceOpen extends WorkspaceOpenCommandBuildResult {
-    selected: SelectedWorkspace;
-    opener: WorkspacePreferredOpener;
-    initiative: InitiativeViewReference | null;
-    workspaceContext: WorkspaceContextState | null;
-    warnings: WorkspaceStatus[];
-}
-export interface WorkspaceOpenJsonPayload {
-    schema_version: 1;
-    workspace: {
-        name: string;
-        root: string;
-    };
-    context: {
-        context_store: {
-            id: string;
-            root: string;
-            selector?: ContextStoreBinding['selector'];
-        };
-        initiative: {
-            id: string;
-            title: string;
-            root: string;
-            metadata_path: string;
-            store_path: string;
-        };
-    } | null;
-    generated_files: {
-        agents: string;
-        code_workspace: string;
-    };
-    opened_roots: PreparedWorkspaceOpen['openedRoots'];
-    skipped_roots: Array<{
-        kind: 'link';
-        name: string;
-        path: string | null;
-        reason: PreparedWorkspaceOpen['skipped'][number]['reason'];
-    }>;
-    advisory_edit_boundaries: {
-        allowed_edit_roots: string[];
-        coordination_roots: string[];
-        enforcement: 'advisory';
-    };
-    opener: PreparedWorkspaceOpen['opener'] & {
-        label: string;
-    };
-    launch: {
-        attempted: true;
-        status: 'succeeded';
-    };
-    warnings: WorkspaceStatus[];
-    status: WorkspaceStatus[];
-}
-export declare function assertWorkspaceOpenSupportedOptions(options: WorkspaceOpenOptions): void;
-export declare function prepareWorkspaceOpen(positionalName: string | undefined, options: WorkspaceOpenOptions): Promise<PreparedWorkspaceOpen>;
-export declare function buildWorkspaceOpenJsonPayload(prepared: PreparedWorkspaceOpen): WorkspaceOpenJsonPayload;
-//# sourceMappingURL=open-view.d.ts.map

package/dist/commands/workspace/open-view.js

@@ -1,249 +0,0 @@
-import { InitiativeResolutionError, resolveInitiativeViewReference, resolveSelectedInitiativeViewReference, } from '../../core/collections/initiatives/index.js';
-import { createPathContextStoreBinding, createRegisteredContextStoreBinding, formatContextStoreBinding, resolveContextStoreBinding, } from '../../core/context-store/index.js';
-import { createWorkspaceInitiativeContext, getWorkspaceContextInitiativeId, getWorkspaceOpenerLabel, } from '../../core/workspace/index.js';
-import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
-import { assertWorkspaceOpenerAvailable, buildWorkspaceOpenCommandForState, readWorkspaceOpenState, } from './open.js';
-import { selectOrCreateWorkspaceForInitiativeOpen, } from './operations.js';
-import { selectWorkspaceOpenTarget } from './open-target-selection.js';
-import { WorkspaceCliError, asErrorMessage, } from './types.js';
-import { resolveWorkspaceOpenOpener, resolveWorkspaceOpenOpenerOverride, } from './opener-selection.js';
-import { promptSetupLinks } from './setup-prompts.js';
-export function assertWorkspaceOpenSupportedOptions(options) {
-    if (!options.initiative && (options.store || options.storePath)) {
-        throw new WorkspaceCliError('workspace open accepts --store or --store-path only with --initiative.', 'workspace_open_store_without_initiative', {
-            target: 'workspace.initiative',
-            fix: 'Use openspec workspace open --initiative <id> --store <store>.',
-        });
-    }
-    if (options.prepareOnly) {
-        throw new WorkspaceCliError('workspace open supports launching through a selected opener; preview output is reserved for a future context/query surface.', 'workspace_open_prepare_only_unsupported', {
-            target: 'workspace.open',
-            fix: 'Run openspec workspace open with --agent <tool> or --editor.',
-        });
-    }
-    if (options.change) {
-        throw new WorkspaceCliError('workspace open currently supports root workspace open only; change-scoped open belongs to future workspace change planning.', 'workspace_open_change_unsupported', {
-            target: 'workspace.change',
-            fix: 'Open the root workspace, then start implementation from an explicit change workflow.',
-        });
-    }
-}
-function resolveOpenWorkspaceName(positionalName, options) {
-    if (positionalName && options.workspace && positionalName !== options.workspace) {
-        throw new WorkspaceCliError(`Conflicting workspace selectors: positional '${positionalName}' and --workspace '${options.workspace}'.`, 'workspace_selection_conflict', {
-            target: 'workspace.name',
-            fix: 'Use either the positional workspace name or --workspace with the same value.',
-        });
-    }
-    return positionalName ?? options.workspace;
-}
-function initiativeErrorAsWorkspaceError(error) {
-    if (error instanceof InitiativeResolutionError) {
-        return new WorkspaceCliError(error.message, error.code, {
-            target: error.target,
-            fix: error.fix,
-            details: error.details,
-        });
-    }
-    return new WorkspaceCliError(asErrorMessage(error), 'initiative_error');
-}
-async function resolveWorkspaceOpenInitiative(options) {
-    if (!options.initiative) {
-        return null;
-    }
-    try {
-        return await resolveInitiativeViewReference(options.initiative, {
-            store: options.store,
-            storePath: options.storePath,
-        });
-    }
-    catch (error) {
-        throw initiativeErrorAsWorkspaceError(error);
-    }
-}
-async function resolveStoredWorkspaceInitiative(context) {
-    const initiativeId = getWorkspaceContextInitiativeId(context);
-    try {
-        const resolvedStore = await resolveContextStoreBinding(context.store);
-        const selected = {
-            id: resolvedStore.id,
-            root: resolvedStore.root,
-            source: resolvedStore.source,
-        };
-        const initiative = await resolveSelectedInitiativeViewReference(selected, initiativeId);
-        return {
-            initiative,
-            warnings: resolvedStore.warnings.map(contextStoreBindingWarningToStatus),
-        };
-    }
-    catch (error) {
-        if (error instanceof InitiativeResolutionError) {
-            throw initiativeErrorAsWorkspaceError(error);
-        }
-        throw new WorkspaceCliError(`Workspace context store '${formatContextStoreBinding(context.store)}' could not be read: ${asErrorMessage(error)}`, 'workspace_context_store_unavailable', {
-            target: 'workspace.context.store',
-            fix: context.store.selector.kind === 'registry'
-                ? 'openspec context-store doctor'
-                : 'Check the path in .openspec-workspace/view.yaml.',
-        });
-    }
-}
-function contextStoreBindingWarningToStatus(warning) {
-    return {
-        severity: 'warning',
-        code: warning.code,
-        message: warning.message,
-        target: warning.target ? `workspace.context.store.${warning.target}` : 'workspace.context.store',
-        ...(warning.fix ? { fix: warning.fix } : {}),
-    };
-}
-function contextStoreBindingFromInitiative(initiative) {
-    return initiative.storeSource === 'path'
-        ? createPathContextStoreBinding({
-            id: initiative.store,
-            path: initiative.storeRoot,
-        })
-        : createRegisteredContextStoreBinding(initiative.store);
-}
-function toWorkspaceOpenResolvedContext(initiative) {
-    return {
-        contextStore: {
-            id: initiative.store,
-            root: initiative.storeRoot,
-        },
-        initiative: {
-            id: initiative.id,
-            title: initiative.title,
-            root: initiative.root,
-            metadataPath: initiative.metadataPath,
-            storePath: initiative.storePath,
-        },
-    };
-}
-function buildSkippedRootWarnings(skipped) {
-    return skipped.map((link) => {
-        const location = link.path ?? '(no local path recorded)';
-        return {
-            severity: 'warning',
-            code: 'workspace_open_link_skipped',
-            message: `Skipped linked repo or folder '${link.name}' because ${location} is not available.`,
-            target: `links.${link.name}.path`,
-            fix: `openspec workspace relink ${link.name} /path/to/${link.name}`,
-        };
-    });
-}
-export async function prepareWorkspaceOpen(positionalName, options) {
-    assertWorkspaceOpenSupportedOptions(options);
-    const workspaceName = resolveOpenWorkspaceName(positionalName, options);
-    const openerOverride = resolveWorkspaceOpenOpenerOverride(options);
-    const requestedInitiative = await resolveWorkspaceOpenInitiative(options);
-    const target = requestedInitiative
-        ? { kind: 'initiative', initiative: requestedInitiative, status: [] }
-        : await selectWorkspaceOpenTarget(workspaceName, options);
-    const interactiveCreate = target.kind === 'initiative'
-        && !options.json
-        && !resolveNoInteractive(options)
-        && isInteractive(options);
-    const baseSelected = target.kind === 'initiative'
-        ? (await selectOrCreateWorkspaceForInitiativeOpen({
-            workspaceName,
-            context: createWorkspaceInitiativeContext(contextStoreBindingFromInitiative(target.initiative), target.initiative.id),
-            preferredOpener: openerOverride,
-            linksForNewWorkspace: interactiveCreate
-                ? () => promptSetupLinks({
-                    heading: 'Link repos or folders for this workspace',
-                    intro: 'Choose local repos or folders to include when opening this initiative, or create the view without links for now.',
-                    allowEmpty: true,
-                    emptyName: 'Create without linked repos',
-                    emptyShort: 'Create without links',
-                    emptyDescription: 'Create the local workspace view and add repos or folders later',
-                    finishName: 'Create and open workspace',
-                    finishShort: 'Create and open',
-                    finishDescription: 'Create the local workspace view and continue opening it',
-                })
-                : undefined,
-        })).selected
-        : target.selected;
-    const selected = {
-        ...baseSelected,
-        status: [...baseSelected.status, ...target.status],
-    };
-    const state = await readWorkspaceOpenState(selected);
-    const stored = target.kind === 'workspace' && state.viewState.context
-        ? await resolveStoredWorkspaceInitiative(state.viewState.context)
-        : null;
-    const initiative = target.kind === 'initiative' ? target.initiative : stored?.initiative ?? null;
-    const resolvedContext = initiative ? toWorkspaceOpenResolvedContext(initiative) : null;
-    const opener = await resolveWorkspaceOpenOpener(state.viewState, options);
-    assertWorkspaceOpenerAvailable(opener, state.codeWorkspacePath);
-    const buildResult = await buildWorkspaceOpenCommandForState(opener, selected.root, state, resolvedContext);
-    return {
-        ...buildResult,
-        selected,
-        opener,
-        initiative,
-        workspaceContext: state.viewState.context,
-        warnings: [
-            ...selected.status,
-            ...(stored?.warnings ?? []),
-            ...buildSkippedRootWarnings(buildResult.skipped),
-        ],
-    };
-}
-export function buildWorkspaceOpenJsonPayload(prepared) {
-    const linkedEditRoots = prepared.openedRoots
-        .filter((root) => root.kind === 'link')
-        .map((root) => root.path);
-    return {
-        schema_version: 1,
-        workspace: {
-            name: prepared.selected.name,
-            root: prepared.selected.root,
-        },
-        context: prepared.initiative
-            ? {
-                context_store: {
-                    id: prepared.initiative.store,
-                    root: prepared.initiative.storeRoot,
-                    ...(prepared.workspaceContext
-                        ? { selector: prepared.workspaceContext.store.selector }
-                        : {}),
-                },
-                initiative: {
-                    id: prepared.initiative.id,
-                    title: prepared.initiative.title,
-                    root: prepared.initiative.root,
-                    metadata_path: prepared.initiative.metadataPath,
-                    store_path: prepared.initiative.storePath,
-                },
-            }
-            : null,
-        generated_files: {
-            agents: prepared.generated.agentsPath,
-            code_workspace: prepared.generated.codeWorkspacePath,
-        },
-        opened_roots: prepared.openedRoots,
-        skipped_roots: prepared.skipped.map((link) => ({
-            kind: 'link',
-            name: link.name,
-            path: link.path,
-            reason: link.reason,
-        })),
-        advisory_edit_boundaries: {
-            allowed_edit_roots: linkedEditRoots,
-            coordination_roots: prepared.initiative ? [prepared.initiative.root] : [],
-            enforcement: 'advisory',
-        },
-        opener: {
-            ...prepared.opener,
-            label: getWorkspaceOpenerLabel(prepared.opener),
-        },
-        launch: {
-            attempted: true,
-            status: 'succeeded',
-        },
-        warnings: prepared.warnings,
-        status: [],
-    };
-}
-//# sourceMappingURL=open-view.js.map

package/dist/commands/workspace/open.d.ts

@@ -1,37 +0,0 @@
-import { spawn as nodeSpawn } from 'node:child_process';
-import { WorkspacePreferredOpener, WorkspaceViewState, WorkspaceOpenResolvedContext, WorkspaceOpenSurfaceGeneration, WorkspaceSkippedOpenLink } from '../../core/workspace/index.js';
-import { SelectedWorkspace } from './types.js';
-export declare const WORKSPACE_OPEN_MINIMAL_PROMPT = "Open this OpenSpec workspace.";
-export interface WorkspaceOpenState {
-    viewState: WorkspaceViewState;
-    codeWorkspacePath: string;
-}
-export interface WorkspaceOpenLaunchCommand {
-    executable: string;
-    args: string[];
-    cwd: string;
-    openerLabel: string;
-}
-export type WorkspaceOpenedRoot = {
-    kind: 'workspace' | 'initiative' | 'link';
-    name?: string;
-    path: string;
-};
-export interface WorkspaceOpenCommandBuildResult {
-    command: WorkspaceOpenLaunchCommand;
-    skipped: WorkspaceSkippedOpenLink[];
-    generated: WorkspaceOpenSurfaceGeneration;
-    openedRoots: WorkspaceOpenedRoot[];
-}
-export type WorkspaceOpenSpawn = typeof nodeSpawn;
-export interface WorkspaceOpenLaunchOptions {
-    spawn?: WorkspaceOpenSpawn;
-    isExecutableAvailable?: (executable: string) => boolean;
-    stdio?: 'inherit' | 'ignore';
-}
-export declare function readWorkspaceOpenState(selected: SelectedWorkspace): Promise<WorkspaceOpenState>;
-export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, attachedPaths: string[]): WorkspaceOpenLaunchCommand;
-export declare function assertWorkspaceOpenerAvailable(opener: WorkspacePreferredOpener, codeWorkspacePath: string, isExecutableAvailable?: (executable: string) => boolean): void;
-export declare function buildWorkspaceOpenCommandForState(opener: WorkspacePreferredOpener, workspaceRoot: string, state: WorkspaceOpenState, resolvedContext?: WorkspaceOpenResolvedContext | null): Promise<WorkspaceOpenCommandBuildResult>;
-export declare function launchWorkspaceOpenCommand(command: WorkspaceOpenLaunchCommand, options?: WorkspaceOpenLaunchOptions): Promise<void>;
-//# sourceMappingURL=open.d.ts.map

package/dist/commands/workspace/open.js

@@ -1,110 +0,0 @@
-import { createRequire } from 'node:module';
-import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceViewState, syncWorkspaceOpenSurface, } from '../../core/workspace/index.js';
-import { WorkspaceCliError, asErrorMessage } from './types.js';
-export const WORKSPACE_OPEN_MINIMAL_PROMPT = 'Open this OpenSpec workspace.';
-const CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS = ['--sandbox', 'workspace-write'];
-const require = createRequire(import.meta.url);
-const spawn = require('cross-spawn');
-function isCodexCliOpener(opener) {
-    const openerId = opener.id;
-    return opener.kind === 'agent' && (openerId === 'codex-cli' || openerId === 'codex');
-}
-export async function readWorkspaceOpenState(selected) {
-    const viewState = await readWorkspaceViewState(selected.root);
-    return {
-        viewState,
-        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, viewState.name),
-    };
-}
-export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, attachedPaths) {
-    const executable = getWorkspaceOpenerExecutable(opener);
-    const openerLabel = getWorkspaceOpenerLabel(opener);
-    if (opener.kind === 'editor' || opener.id === 'github-copilot') {
-        return {
-            executable,
-            args: [codeWorkspacePath],
-            cwd: workspaceRoot,
-            openerLabel,
-        };
-    }
-    return {
-        executable,
-        args: [
-            ...(isCodexCliOpener(opener) && attachedPaths.length > 0
-                ? CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS
-                : []),
-            ...attachedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
-            WORKSPACE_OPEN_MINIMAL_PROMPT,
-        ],
-        cwd: workspaceRoot,
-        openerLabel,
-    };
-}
-export function assertWorkspaceOpenerAvailable(opener, codeWorkspacePath, isExecutableAvailable = isWorkspaceExecutableAvailable) {
-    const executable = getWorkspaceOpenerExecutable(opener);
-    if (isExecutableAvailable(executable)) {
-        return;
-    }
-    const openerLabel = getWorkspaceOpenerLabel(opener);
-    const manualPath = executable === 'code'
-        ? ` You can open the workspace file manually: ${codeWorkspacePath}`
-        : '';
-    throw new WorkspaceCliError(`${openerLabel} requires '${executable}', but '${executable}' was not found on PATH.${manualPath}`, 'workspace_opener_unavailable', {
-        target: 'workspace.opener',
-        fix: `Install '${executable}' or choose another opener.`,
-    });
-}
-export async function buildWorkspaceOpenCommandForState(opener, workspaceRoot, state, resolvedContext) {
-    const openSurface = await syncWorkspaceOpenSurface(workspaceRoot, state.viewState, resolvedContext);
-    const openedRoots = [
-        { kind: 'workspace', path: workspaceRoot },
-        ...(resolvedContext
-            ? [
-                {
-                    kind: 'initiative',
-                    name: resolvedContext.initiative.id,
-                    path: resolvedContext.initiative.root,
-                },
-            ]
-            : []),
-        ...openSurface.links.map((link) => ({
-            kind: 'link',
-            name: link.name,
-            path: link.path,
-        })),
-    ];
-    return {
-        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openedRoots
-            .filter((root) => root.kind !== 'workspace')
-            .map((root) => root.path)),
-        skipped: openSurface.skipped,
-        generated: openSurface.generated,
-        openedRoots,
-    };
-}
-export async function launchWorkspaceOpenCommand(command, options = {}) {
-    const spawnCommand = options.spawn ?? spawn;
-    await new Promise((resolve, reject) => {
-        const child = spawnCommand(command.executable, command.args, {
-            cwd: command.cwd,
-            stdio: options.stdio ?? 'inherit',
-            shell: false,
-        });
-        child.on('error', (error) => {
-            reject(new WorkspaceCliError(`Could not launch ${command.openerLabel}: ${asErrorMessage(error)}`, 'workspace_opener_launch_failed', {
-                target: 'workspace.opener',
-            }));
-        });
-        child.on('close', (code, signal) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            const reason = signal ? `signal ${signal}` : `exit code ${code}`;
-            reject(new WorkspaceCliError(`${command.openerLabel} exited with ${reason}.`, 'workspace_opener_launch_failed', {
-                target: 'workspace.opener',
-            }));
-        });
-    });
-}
-//# sourceMappingURL=open.js.map

package/dist/commands/workspace/opener-selection.d.ts

@@ -1,11 +0,0 @@
-import { WorkspacePreferredOpener } from '../../core/workspace/index.js';
-import { WorkspaceOpenOptions } from './types.js';
-export declare function promptPreferredOpener(message: string, openerChoices?: import("../../core/workspace/openers.js").WorkspaceOpenerChoice[]): Promise<WorkspacePreferredOpener>;
-export declare function parseSetupOpenerOption(opener: string | undefined): WorkspacePreferredOpener | undefined;
-export declare function parseWorkspaceAgentOverride(agent: string): WorkspacePreferredOpener;
-export declare function getPreferredWorkspaceSkillAgentId(preferredOpener: WorkspacePreferredOpener | undefined): string | null;
-export declare function resolveWorkspaceOpenOpenerOverride(options: WorkspaceOpenOptions): WorkspacePreferredOpener | undefined;
-export declare function resolveWorkspaceOpenOpener(localState: {
-    preferred_opener?: WorkspacePreferredOpener;
-}, options: WorkspaceOpenOptions): Promise<WorkspacePreferredOpener>;
-//# sourceMappingURL=opener-selection.d.ts.map