@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.0

package/dist/lib/git-worktree.js

@@ -1,306 +1,36 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-let gitExecFn = defaultGitExec;
-/** Raised well above the 1 MB default: profiles, permission sets, and long logs exceed it. */
-const GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
-async function defaultGitExec(args) {
-    const { stderr, stdout } = await execFileAsync('git', args, { maxBuffer: GIT_MAX_BUFFER_BYTES });
-    return {
-        stderr: stderr.toString(),
-        stdout: stdout.toString(),
-    };
-}
-export function parsePorcelainPaths(stdout) {
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length > 0)
-        .map((line) => line.slice(3));
-}
-export async function listPendingChanges() {
-    const { stdout } = await gitExecFn(['status', '--porcelain', '--untracked-files=no', '--no-renames']);
-    return parsePorcelainPaths(stdout);
-}
-export async function getCurrentBranch() {
-    const { stdout } = await gitExecFn(['rev-parse', '--abbrev-ref', 'HEAD']);
-    return stdout.trim();
-}
-export async function isInsideGitWorkTree() {
-    try {
-        const { stdout } = await gitExecFn(['rev-parse', '--is-inside-work-tree']);
-        return stdout.trim() === 'true';
-    }
-    catch {
-        return false;
-    }
-}
-export async function getGitRepoRoot() {
-    const { stdout } = await gitExecFn(['rev-parse', '--show-toplevel']);
-    return stdout.trim();
-}
-export async function getRemoteUrl(remote = 'origin') {
-    try {
-        const { stdout } = await gitExecFn(['remote', 'get-url', remote]);
-        const url = stdout.trim();
-        return url.length > 0 ? url : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function stageAndCommit(message, paths) {
-    if (paths.length === 0) {
-        throw new Error('stageAndCommit requires at least one path');
-    }
-    await gitExecFn(['add', '--', ...paths]);
-    await gitExecFn(['commit', '-m', message]);
-}
-/** Commit all tracked modifications in the working tree (`git commit -am`). */
-export async function commitAllTrackedChanges(message) {
-    await gitExecFn(['commit', '-a', '-m', message]);
-}
-/** Commit staged changes only (`git commit -m`). */
-export async function commitStagedChanges(message) {
-    await gitExecFn(['commit', '-m', message]);
-}
-/** Create a commit with no file changes (`git commit --allow-empty -m`). */
-export async function commitAllowEmpty(message) {
-    await gitExecFn(['commit', '--allow-empty', '-m', message]);
-}
-export async function listStagedChanges() {
-    const { stdout } = await gitExecFn(['diff', '--cached', '--name-only']);
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-export async function getHeadCommitId() {
-    const { stdout } = await gitExecFn(['rev-parse', 'HEAD']);
-    return stdout.trim();
-}
-function gitErrorText(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    let stderr = '';
-    if (typeof error === 'object' && error !== null && 'stderr' in error) {
-        const value = error.stderr;
-        if (typeof value === 'string') {
-            stderr = value;
-        }
-        else if (Buffer.isBuffer(value)) {
-            stderr = value.toString();
-        }
-    }
-    return `${message}\n${stderr}`;
-}
-function isMissingRemoteRefError(error) {
-    return /couldn'?t find remote ref/i.test(gitErrorText(error));
-}
-export async function fetchOriginBranch(branch) {
-    await gitExecFn(['fetch', 'origin', originFetchRefspec(branch)]);
-}
-/** Fetch `origin/<branch>` when that remote ref exists. Missing remote refs are not errors. */
-export async function fetchOriginBranchIfExists(branch) {
-    try {
-        await fetchOriginBranch(branch);
-        return true;
-    }
-    catch (error) {
-        if (isMissingRemoteRefError(error)) {
-            return false;
-        }
-        throw error;
-    }
-}
-/** Remote-tracking ref for a recorded pipeline base branch (`main` → `origin/main`). */
-export function originBranchRef(branch) {
-    return `origin/${branch}`;
-}
-/** Fetch refspec that updates `origin/<branch>` (`main` → `+refs/heads/main:refs/remotes/origin/main`). */
-export function originFetchRefspec(branch) {
-    return `+refs/heads/${branch}:refs/remotes/origin/${branch}`;
-}
-export async function checkoutBranch(branch) {
-    await gitExecFn(['checkout', branch]);
-}
-/** True when `refs/heads/<branch>` exists locally. */
-export async function localBranchExists(branch) {
-    try {
-        await gitExecFn(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check out the first candidate that exists as a local branch.
- * When none exist, leave HEAD unchanged and return the current branch.
- */
-export async function checkoutPreferredBranch(candidates) {
-    const current = await getCurrentBranch();
-    for (const candidate of candidates) {
-        const branch = candidate?.trim();
-        if (branch === undefined || branch.length === 0) {
-            continue;
-        }
-        if (!(await localBranchExists(branch))) {
-            continue;
-        }
-        if (branch === current) {
-            return { branch, checkedOut: false };
-        }
-        await checkoutBranch(branch);
-        return { branch, checkedOut: true };
-    }
-    return { branch: current, checkedOut: false };
-}
-export async function pushOriginBranch(branch) {
-    await gitExecFn(['push', 'origin', branch]);
-}
-const PULL_ORIGIN_MAX_ATTEMPTS = 3;
-/** Best-effort abort of an in-progress rebase (no-op when none is in progress). */
-async function abortRebase() {
-    try {
-        await gitExecFn(['rebase', '--abort']);
-    }
-    catch {
-        // No rebase in progress (or abort unavailable); ignore.
-    }
-}
-/**
- * Sync HEAD with `origin/<branch>` in two stages (fetch, then rebase).
- * Avoids `git pull origin <branch>`, which can fail with
- * "Cannot rebase onto multiple branches" when pull.rebase is enabled.
- * Retries the full sequence a few times; aborts a partial rebase between attempts.
- */
-export async function pullOriginBranch(branch) {
-    let lastError;
-    for (let attempt = 1; attempt <= PULL_ORIGIN_MAX_ATTEMPTS; attempt++) {
-        try {
-            // eslint-disable-next-line no-await-in-loop -- sequential fetch/rebase attempts
-            await fetchOriginBranch(branch);
-            // eslint-disable-next-line no-await-in-loop -- sequential fetch/rebase attempts
-            await gitExecFn(['rebase', `origin/${branch}`]);
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            // eslint-disable-next-line no-await-in-loop -- clear partial rebase before retry
-            await abortRebase();
-            if (attempt >= PULL_ORIGIN_MAX_ATTEMPTS) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
-}
-/**
- * Merge `branch` into HEAD, preferring the merged branch on conflicts and ignoring space-only changes.
- * Uses `-X theirs` (strategy option), not `-s theirs` — Git has no `theirs` merge strategy.
- * When syncing into the dev-org branch, "theirs" is the feature branch being merged in.
- */
-export async function mergeTheirsIgnoreSpaceChange(branch) {
-    await gitExecFn(['merge', '-X', 'theirs', '-X', 'ignore-space-change', branch]);
-}
-/** Best-effort abort of an in-progress merge (no-op when none is in progress). */
-export async function abortMerge() {
-    try {
-        await gitExecFn(['merge', '--abort']);
-    }
-    catch {
-        // No merge in progress (or abort unavailable); ignore.
-    }
-}
-/** Discard uncommitted tracked changes in the working tree. */
-export async function resetHardHead() {
-    await gitExecFn(['reset', '--hard', 'HEAD']);
-}
-/**
- * After a failed work-push side effect, discard local changes and return to the feature branch.
- */
-export async function restoreFeatureBranch(branch) {
-    await abortMerge();
-    try {
-        await resetHardHead();
-    }
-    catch {
-        // Ignore reset failures so checkout can still be attempted.
-    }
-    await checkoutBranch(branch);
-}
-/** Count commits reachable from HEAD that are not on `baseRef`. */
-export async function countCommitsSince(baseRef) {
-    const { stdout } = await gitExecFn(['rev-list', '--count', `${baseRef}..HEAD`]);
-    const count = Number.parseInt(stdout.trim(), 10);
-    return Number.isFinite(count) ? count : 0;
-}
-/** True when origin/<branch> is missing or HEAD has commits not on the remote branch. */
-export async function hasUnpushedCommits(branch) {
-    try {
-        await gitExecFn(['rev-parse', '--verify', `origin/${branch}`]);
-    }
-    catch {
-        return true;
-    }
-    return (await countCommitsSince(`origin/${branch}`)) > 0;
-}
-/** Pretty format for name-status logs: hash, subject, committer name/email/date. */
-export const NAME_STATUS_PRETTY_FORMAT = '%H%x00%s%x00%cn%x00%ce%x00%cI';
-export async function getCommitsNameStatus(baseRef) {
-    const { stdout } = await gitExecFn([
-        'log',
-        '--reverse',
-        '--name-status',
-        `--pretty=format:${NAME_STATUS_PRETTY_FORMAT}`,
-        `${baseRef}..HEAD`,
-    ]);
-    return stdout;
-}
-/** Commit where the branch left `baseRef`, falling back to `baseRef` itself. */
-export async function getMergeBase(baseRef, ref = 'HEAD') {
-    try {
-        const { stdout } = await gitExecFn(['merge-base', baseRef, ref]);
-        const mergeBase = stdout.trim();
-        return mergeBase.length > 0 ? mergeBase : baseRef;
-    }
-    catch {
-        return baseRef;
-    }
-}
-/** Contents of a tracked file at a git ref, or `''` when the ref does not contain it. */
-export async function getFileAtRef(ref, filePath) {
-    try {
-        const { stdout } = await gitExecFn(['show', `${ref}:${filePath}`]);
-        return stdout;
-    }
-    catch {
-        return '';
-    }
-}
-function isBranchAlreadyExistsError(error) {
-    return /already exists/i.test(gitErrorText(error));
-}
-export async function checkoutFeatureBranch(branch, baseBranch, options = {}) {
-    const startPoint = options.remoteExists === true ? originBranchRef(branch) : originBranchRef(baseBranch);
-    try {
-        await gitExecFn(['checkout', '-b', branch, startPoint]);
-        return { branch, created: true, startPoint };
-    }
-    catch (error) {
-        if (!isBranchAlreadyExistsError(error)) {
-            throw error;
-        }
-        await gitExecFn(['checkout', branch]);
-        return { branch, created: false, startPoint };
-    }
-}
-// Test-only hook
-export function setGitExecForTests(fn) {
-    gitExecFn = fn;
-}
-// Test-only hook
-export function resetGitExecForTests() {
-    gitExecFn = defaultGitExec;
-}
-//# sourceMappingURL=git-worktree.js.map
+import {modules} from './runtime.js';
+const NAME_STATUS_PRETTY_FORMAT = modules["git-worktree.js"]["NAME_STATUS_PRETTY_FORMAT"]
+const abortMerge = modules["git-worktree.js"]["abortMerge"]
+const checkoutBranch = modules["git-worktree.js"]["checkoutBranch"]
+const checkoutFeatureBranch = modules["git-worktree.js"]["checkoutFeatureBranch"]
+const checkoutPreferredBranch = modules["git-worktree.js"]["checkoutPreferredBranch"]
+const commitAllTrackedChanges = modules["git-worktree.js"]["commitAllTrackedChanges"]
+const commitAllowEmpty = modules["git-worktree.js"]["commitAllowEmpty"]
+const commitStagedChanges = modules["git-worktree.js"]["commitStagedChanges"]
+const countCommitsSince = modules["git-worktree.js"]["countCommitsSince"]
+const fetchOriginBranch = modules["git-worktree.js"]["fetchOriginBranch"]
+const fetchOriginBranchIfExists = modules["git-worktree.js"]["fetchOriginBranchIfExists"]
+const getCommitsNameStatus = modules["git-worktree.js"]["getCommitsNameStatus"]
+const getCurrentBranch = modules["git-worktree.js"]["getCurrentBranch"]
+const getFileAtRef = modules["git-worktree.js"]["getFileAtRef"]
+const getGitRepoRoot = modules["git-worktree.js"]["getGitRepoRoot"]
+const getHeadCommitId = modules["git-worktree.js"]["getHeadCommitId"]
+const getMergeBase = modules["git-worktree.js"]["getMergeBase"]
+const getRemoteUrl = modules["git-worktree.js"]["getRemoteUrl"]
+const hasUnpushedCommits = modules["git-worktree.js"]["hasUnpushedCommits"]
+const isInsideGitWorkTree = modules["git-worktree.js"]["isInsideGitWorkTree"]
+const listPendingChanges = modules["git-worktree.js"]["listPendingChanges"]
+const listStagedChanges = modules["git-worktree.js"]["listStagedChanges"]
+const localBranchExists = modules["git-worktree.js"]["localBranchExists"]
+const mergeTheirsIgnoreSpaceChange = modules["git-worktree.js"]["mergeTheirsIgnoreSpaceChange"]
+const originBranchRef = modules["git-worktree.js"]["originBranchRef"]
+const originFetchRefspec = modules["git-worktree.js"]["originFetchRefspec"]
+const parsePorcelainPaths = modules["git-worktree.js"]["parsePorcelainPaths"]
+const pullOriginBranch = modules["git-worktree.js"]["pullOriginBranch"]
+const pushOriginBranch = modules["git-worktree.js"]["pushOriginBranch"]
+const resetGitExecForTests = modules["git-worktree.js"]["resetGitExecForTests"]
+const resetHardHead = modules["git-worktree.js"]["resetHardHead"]
+const restoreFeatureBranch = modules["git-worktree.js"]["restoreFeatureBranch"]
+const setGitExecForTests = modules["git-worktree.js"]["setGitExecForTests"]
+const stageAndCommit = modules["git-worktree.js"]["stageAndCommit"]
+export {NAME_STATUS_PRETTY_FORMAT, abortMerge, checkoutBranch, checkoutFeatureBranch, checkoutPreferredBranch, commitAllTrackedChanges, commitAllowEmpty, commitStagedChanges, countCommitsSince, fetchOriginBranch, fetchOriginBranchIfExists, getCommitsNameStatus, getCurrentBranch, getFileAtRef, getGitRepoRoot, getHeadCommitId, getMergeBase, getRemoteUrl, hasUnpushedCommits, isInsideGitWorkTree, listPendingChanges, listStagedChanges, localBranchExists, mergeTheirsIgnoreSpaceChange, originBranchRef, originFetchRefspec, parsePorcelainPaths, pullOriginBranch, pushOriginBranch, resetGitExecForTests, resetHardHead, restoreFeatureBranch, setGitExecForTests, stageAndCommit};

package/dist/lib/ide-command-events.js

@@ -1,248 +1,25 @@
-import { realpathSync } from 'node:fs';
-import { readdir, readFile } from 'node:fs/promises';
-import net from 'node:net';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { v7 as uuidv7 } from 'uuid';
-export const IDE_COMMAND_EVENTS_PROTOCOL_VERSION = 1;
-export const IDE_COMMAND_COMPLETED_TYPE = 'command.completed';
-export const IDE_COMMAND_EVENT_TIMEOUT_MS = 150;
-export const IDE_LISTENER_DESCRIPTOR_EXTENSION = '.json';
-export const IDE_POSIX_SOCKET_EXTENSION = '.sock';
-export const IDE_WINDOWS_PIPE_PREFIX = String.raw `\\.\pipe\agentia-cli-ide-`;
-export const IDE_LISTENERS_DIRNAME = 'ide-listeners';
-export const IDE_RUNTIME_DIRNAME = 'agentia-cli';
-const ENV_LISTENERS_DIR = 'AGENTIA_TEST_IDE_LISTENERS_DIR';
-const WINDOWS_PIPE_NAME_PATTERN = /^[\w.-]+$/;
-let testDeps;
-let commandError;
-export function setIdeCommandEventDepsForTests(deps) {
-    testDeps = deps;
-}
-export function resetIdeCommandEventDepsForTests() {
-    testDeps = undefined;
-    commandError = undefined;
-}
-export function rememberIdeCommandError(error) {
-    commandError = error;
-}
-export function consumeIdeCommandError() {
-    const error = commandError;
-    commandError = undefined;
-    return error;
-}
-export function defaultIdeListenersDir(tmp = tmpdir()) {
-    return path.join(tmp, IDE_RUNTIME_DIRNAME, IDE_LISTENERS_DIRNAME);
-}
-export function ideListenersDir() {
-    return process.env[ENV_LISTENERS_DIR] ?? testDeps?.listenersDir ?? defaultIdeListenersDir();
-}
-export function canonicalizePath(value, pathApi = path) {
-    const resolved = pathApi.resolve(value);
-    try {
-        return realpathSync(resolved);
-    }
-    catch {
-        return resolved;
-    }
-}
-export function workspaceContainsCwd(workspaceRoot, cwd, options = {}) {
-    const pathApi = options.pathApi ?? path;
-    const caseSensitive = options.caseSensitive ?? process.platform !== 'win32';
-    const root = normalizeForCompare(workspaceRoot, pathApi, caseSensitive);
-    const current = normalizeForCompare(cwd, pathApi, caseSensitive);
-    if (current === root) {
-        return true;
-    }
-    const prefix = root.endsWith(pathApi.sep) ? root : `${root}${pathApi.sep}`;
-    return current.startsWith(prefix);
-}
-export function isValidIdeIpcEndpoint(endpoint, options) {
-    const platform = options.platform ?? process.platform;
-    if (platform === 'win32') {
-        if (!endpoint.startsWith(IDE_WINDOWS_PIPE_PREFIX)) {
-            return false;
-        }
-        return WINDOWS_PIPE_NAME_PATTERN.test(endpoint.slice(IDE_WINDOWS_PIPE_PREFIX.length));
-    }
-    const pathApi = options.pathApi ?? path;
-    if (!pathApi.isAbsolute(endpoint)) {
-        return false;
-    }
-    const resolvedEndpoint = pathApi.resolve(endpoint);
-    if (!resolvedEndpoint.endsWith(IDE_POSIX_SOCKET_EXTENSION)) {
-        return false;
-    }
-    return isPathInside(options.listenersDir, resolvedEndpoint, pathApi);
-}
-export function parseIdeListenerDescriptor(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (value.protocolVersion !== IDE_COMMAND_EVENTS_PROTOCOL_VERSION) {
-        return undefined;
-    }
-    if (typeof value.endpoint !== 'string' || value.endpoint.trim().length === 0) {
-        return undefined;
-    }
-    if (!Array.isArray(value.workspaceRoots) || value.workspaceRoots.length === 0) {
-        return undefined;
-    }
-    const workspaceRoots = value.workspaceRoots.filter((root) => typeof root === 'string' && root.trim().length > 0);
-    if (workspaceRoots.length === 0) {
-        return undefined;
-    }
-    return {
-        endpoint: value.endpoint,
-        protocolVersion: value.protocolVersion,
-        workspaceRoots,
-    };
-}
-export function exitCodeFromError(error) {
-    if (error === undefined || error === null) {
-        return 0;
-    }
-    if (isRecord(error) && isRecord(error.oclif) && typeof error.oclif.exit === 'number') {
-        return error.oclif.exit;
-    }
-    return 1;
-}
-export function buildIdeCommandCompletedEvent(input) {
-    const exitCode = exitCodeFromError(input.error);
-    return {
-        cliVersion: input.cliVersion,
-        commandId: input.commandId,
-        cwd: input.cwd,
-        eventId: input.eventId ?? uuidv7(),
-        exitCode,
-        protocolVersion: IDE_COMMAND_EVENTS_PROTOCOL_VERSION,
-        status: exitCode === 0 ? 'success' : 'failure',
-        timestamp: (input.now ?? new Date()).toISOString(),
-        type: IDE_COMMAND_COMPLETED_TYPE,
-    };
-}
-export function frameIdeCommandEvent(event) {
-    return `${JSON.stringify(event)}\n`;
-}
-export async function publishIdeCommandCompleted(input) {
-    try {
-        const commandId = input.commandId.trim();
-        if (commandId.length === 0) {
-            return;
-        }
-        const platform = testDeps?.platform ?? process.platform;
-        const listenersDir = ideListenersDir();
-        const cwd = canonicalizePath(input.cwd ?? process.cwd());
-        const descriptors = await readListenerDescriptors(listenersDir);
-        const endpoints = matchingEndpoints(descriptors, cwd, { listenersDir, platform });
-        if (endpoints.length === 0) {
-            return;
-        }
-        const event = buildIdeCommandCompletedEvent({
-            ...input,
-            commandId,
-            cwd,
-            now: input.now ?? testDeps?.now?.(),
-        });
-        const framed = frameIdeCommandEvent(event);
-        const timeoutMs = testDeps?.timeoutMs ?? IDE_COMMAND_EVENT_TIMEOUT_MS;
-        const sender = testDeps?.sender ?? sendOverIpc;
-        await Promise.race([
-            Promise.allSettled(endpoints.map(async (endpoint) => sender(endpoint, framed, timeoutMs))),
-            delay(timeoutMs),
-        ]);
-    }
-    catch {
-        // IDE notifications are best-effort and must never change CLI output or exit status.
-    }
-}
-export function matchingEndpoints(descriptors, cwd, options) {
-    const endpoints = new Set();
-    const pathApi = options.pathApi ?? path;
-    const platform = options.platform ?? process.platform;
-    const caseSensitive = platform !== 'win32';
-    for (const descriptor of descriptors) {
-        if (!isValidIdeIpcEndpoint(descriptor.endpoint, { listenersDir: options.listenersDir, pathApi, platform })) {
-            continue;
-        }
-        const matches = descriptor.workspaceRoots.some((root) => workspaceContainsCwd(canonicalizePath(root, pathApi), cwd, { caseSensitive, pathApi }));
-        if (matches) {
-            endpoints.add(descriptor.endpoint);
-        }
-    }
-    return [...endpoints];
-}
-async function readListenerDescriptors(listenersDir) {
-    let entries;
-    try {
-        entries = await readdir(listenersDir);
-    }
-    catch {
-        return [];
-    }
-    const descriptors = [];
-    await Promise.all(entries.map(async (entry) => {
-        if (!entry.endsWith(IDE_LISTENER_DESCRIPTOR_EXTENSION)) {
-            return;
-        }
-        try {
-            const contents = await readFile(path.join(listenersDir, entry), 'utf8');
-            const descriptor = parseIdeListenerDescriptor(JSON.parse(contents));
-            if (descriptor !== undefined) {
-                descriptors.push(descriptor);
-            }
-        }
-        catch {
-            // Malformed or unreadable descriptors are ignored.
-        }
-    }));
-    return descriptors;
-}
-function sendOverIpc(endpoint, framedPayload, timeoutMs) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            resolve();
-        };
-        const socket = net.createConnection(endpoint);
-        const timer = setTimeout(() => {
-            socket.destroy();
-            finish();
-        }, timeoutMs);
-        socket.on('connect', () => {
-            socket.write(framedPayload, () => {
-                socket.end();
-            });
-        });
-        socket.on('close', () => {
-            clearTimeout(timer);
-            finish();
-        });
-        socket.on('error', () => {
-            clearTimeout(timer);
-            socket.destroy();
-            finish();
-        });
-    });
-}
-function delay(timeoutMs) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, timeoutMs);
-    });
-}
-function normalizeForCompare(value, pathApi, caseSensitive) {
-    const normalized = pathApi.normalize(pathApi.resolve(value));
-    return caseSensitive ? normalized : normalized.toLowerCase();
-}
-function isPathInside(parent, child, pathApi) {
-    const relative = pathApi.relative(pathApi.resolve(parent), pathApi.resolve(child));
-    return relative !== '' && !relative.startsWith('..') && !pathApi.isAbsolute(relative);
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-//# sourceMappingURL=ide-command-events.js.map
+import {modules} from './runtime.js';
+const IDE_COMMAND_COMPLETED_TYPE = modules["ide-command-events.js"]["IDE_COMMAND_COMPLETED_TYPE"]
+const IDE_COMMAND_EVENTS_PROTOCOL_VERSION = modules["ide-command-events.js"]["IDE_COMMAND_EVENTS_PROTOCOL_VERSION"]
+const IDE_COMMAND_EVENT_TIMEOUT_MS = modules["ide-command-events.js"]["IDE_COMMAND_EVENT_TIMEOUT_MS"]
+const IDE_LISTENERS_DIRNAME = modules["ide-command-events.js"]["IDE_LISTENERS_DIRNAME"]
+const IDE_LISTENER_DESCRIPTOR_EXTENSION = modules["ide-command-events.js"]["IDE_LISTENER_DESCRIPTOR_EXTENSION"]
+const IDE_POSIX_SOCKET_EXTENSION = modules["ide-command-events.js"]["IDE_POSIX_SOCKET_EXTENSION"]
+const IDE_RUNTIME_DIRNAME = modules["ide-command-events.js"]["IDE_RUNTIME_DIRNAME"]
+const IDE_WINDOWS_PIPE_PREFIX = modules["ide-command-events.js"]["IDE_WINDOWS_PIPE_PREFIX"]
+const buildIdeCommandCompletedEvent = modules["ide-command-events.js"]["buildIdeCommandCompletedEvent"]
+const canonicalizePath = modules["ide-command-events.js"]["canonicalizePath"]
+const consumeIdeCommandError = modules["ide-command-events.js"]["consumeIdeCommandError"]
+const defaultIdeListenersDir = modules["ide-command-events.js"]["defaultIdeListenersDir"]
+const exitCodeFromError = modules["ide-command-events.js"]["exitCodeFromError"]
+const frameIdeCommandEvent = modules["ide-command-events.js"]["frameIdeCommandEvent"]
+const ideListenersDir = modules["ide-command-events.js"]["ideListenersDir"]
+const isValidIdeIpcEndpoint = modules["ide-command-events.js"]["isValidIdeIpcEndpoint"]
+const matchingEndpoints = modules["ide-command-events.js"]["matchingEndpoints"]
+const parseIdeListenerDescriptor = modules["ide-command-events.js"]["parseIdeListenerDescriptor"]
+const publishIdeCommandCompleted = modules["ide-command-events.js"]["publishIdeCommandCompleted"]
+const rememberIdeCommandError = modules["ide-command-events.js"]["rememberIdeCommandError"]
+const resetIdeCommandEventDepsForTests = modules["ide-command-events.js"]["resetIdeCommandEventDepsForTests"]
+const setIdeCommandEventDepsForTests = modules["ide-command-events.js"]["setIdeCommandEventDepsForTests"]
+const workspaceContainsCwd = modules["ide-command-events.js"]["workspaceContainsCwd"]
+export {IDE_COMMAND_COMPLETED_TYPE, IDE_COMMAND_EVENTS_PROTOCOL_VERSION, IDE_COMMAND_EVENT_TIMEOUT_MS, IDE_LISTENERS_DIRNAME, IDE_LISTENER_DESCRIPTOR_EXTENSION, IDE_POSIX_SOCKET_EXTENSION, IDE_RUNTIME_DIRNAME, IDE_WINDOWS_PIPE_PREFIX, buildIdeCommandCompletedEvent, canonicalizePath, consumeIdeCommandError, defaultIdeListenersDir, exitCodeFromError, frameIdeCommandEvent, ideListenersDir, isValidIdeIpcEndpoint, matchingEndpoints, parseIdeListenerDescriptor, publishIdeCommandCompleted, rememberIdeCommandError, resetIdeCommandEventDepsForTests, setIdeCommandEventDepsForTests, workspaceContainsCwd};