@envseal/cli 0.1.3 → 0.1.5

package/dist/host-wiring/goose.js

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { mcpLaunch } from './mcp.js';
+export function gooseYamlSnippet(platform = process.platform) {
+    const launch = mcpLaunch(platform);
+    const args = launch.args.map((a) => `"${a}"`).join(', ');
+    return `mcp:
+  servers:
+    envseal-mcp:
+      cmd: ${launch.command}
+      args: [${args}]
+`;
+}
+export function gooseAddHint(platform = process.platform) {
+    const launch = mcpLaunch(platform);
+    const args = launch.args.join(' ');
+    return `goose mcp add envseal-mcp -- ${launch.command} ${args}   # [VERIFY: exact flags for your build]`;
+}
+/**
+ * Goose is print-only: do not invent a verified project schema.
+ * Create `.goose/` so doctor can label the host; MCP stays unwired until the
+ * user runs the printed CLI / yaml themselves.
+ */
+export function writeGooseMarker(root) {
+    const dir = join(root, '.goose');
+    const existed = existsSync(dir);
+    mkdirSync(dir, { recursive: true });
+    return {
+        action: existed ? 'unchanged' : 'created',
+        path: dir,
+        addHint: gooseAddHint(),
+        yamlSnippet: gooseYamlSnippet(),
+    };
+}
+export function inspectGooseProject(root) {
+    const files = [join(root, 'goose.config.yaml'), join(root, '.goose', 'config.yaml')];
+    for (const path of files) {
+        if (!existsSync(path))
+            continue;
+        const text = readFileSync(path, 'utf8');
+        if (/envseal-mcp/.test(text)) {
+            return {
+                wired: true,
+                status: 'wired',
+                commandOk: null,
+                message: `Goose config names envseal-mcp (${path}). [VERIFY]`,
+            };
+        }
+    }
+    return {
+        wired: false,
+        status: 'missing',
+        commandOk: null,
+        message: 'Goose is not OOTB: run `goose mcp add` (see envseal init output) or merge the yaml snippet. envseal does not write ~/.config/goose/. [VERIFY]',
+    };
+}
+//# sourceMappingURL=goose.js.map

package/dist/host-wiring/inspect.d.ts

@@ -0,0 +1,24 @@
+import { type McpInspection } from './mcp.js';
+export type AgentWiringMcp = 'ok' | 'missing' | 'spawn_failed';
+export type AgentWiringInstructions = 'ok' | 'missing';
+export type AgentWiring = {
+    mcp: AgentWiringMcp;
+    instructions: AgentWiringInstructions;
+};
+export type PrimaryHostInspection = {
+    wiring: AgentWiring;
+    mcp?: McpInspection;
+    /** Hosts where MCP is expected in a project file. */
+    mcpRequired: boolean;
+    /** Documented as print-only / not OOTB even after init. */
+    notOotb: boolean;
+    /** Aider: `.env` appears on the `read:` list. */
+    aiderUnsafe: boolean;
+    message: string;
+};
+export declare function inspectPrimaryHostWiring(root: string, hostId: string, options?: {
+    probe?: boolean;
+    platform?: NodeJS.Platform;
+}): PrimaryHostInspection;
+export declare function wiringFailsDoctor(inspection: PrimaryHostInspection): boolean;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/host-wiring/inspect.js

@@ -0,0 +1,102 @@
+import { join } from 'node:path';
+import { inspectAiderConf } from './aider.js';
+import { inspectAgentsMd } from './agents-md.js';
+import { inspectCodexProject } from './codex.js';
+import { inspectContinueProject } from './continue.js';
+import { inspectCopilotSettings } from './copilot.js';
+import { inspectCursorMcp } from './cursor.js';
+import { inspectGooseProject } from './goose.js';
+import { inspectMcpServersFile, mcpWiringState } from './mcp.js';
+import { inspectZedSettings } from './zed.js';
+const MCP_REQUIRED = new Set([
+    'cursor',
+    'claude-code',
+    'windsurf',
+    'cline',
+    'zed',
+    'jetbrains',
+    'copilot',
+    'continue',
+    'codex',
+    'goose',
+]);
+const NOT_OOTB = new Set(['continue', 'goose']);
+function inspectPrimaryMcp(root, hostId, options) {
+    switch (hostId) {
+        case 'cursor':
+            return inspectCursorMcp(root, options);
+        case 'claude-code':
+            return inspectMcpServersFile(join(root, '.mcp.json'), '.mcp.json', options);
+        case 'windsurf':
+            return inspectMcpServersFile(join(root, '.windsurf', 'mcp_config.json'), '.windsurf/mcp_config.json', options);
+        case 'cline':
+            return inspectMcpServersFile(join(root, '.cline', 'mcp_settings.json'), '.cline/mcp_settings.json', options);
+        case 'zed':
+            return inspectZedSettings(root, options);
+        case 'jetbrains':
+            return inspectMcpServersFile(join(root, '.idea', 'mcp.json'), '.idea/mcp.json', options);
+        case 'copilot':
+            return inspectCopilotSettings(root, options);
+        case 'continue':
+            return inspectContinueProject(root);
+        case 'codex':
+            return inspectCodexProject(root);
+        case 'goose':
+            return inspectGooseProject(root);
+        default:
+            return undefined;
+    }
+}
+export function inspectPrimaryHostWiring(root, hostId, options = {}) {
+    const instructions = inspectAgentsMd(root).instructions;
+    const mcpRequired = MCP_REQUIRED.has(hostId);
+    const notOotb = NOT_OOTB.has(hostId);
+    if (hostId === 'aider') {
+        const aider = inspectAiderConf(root);
+        return {
+            wiring: { mcp: 'ok', instructions },
+            mcpRequired: false,
+            notOotb: false,
+            aiderUnsafe: !aider.wired,
+            message: aider.message,
+        };
+    }
+    if (!mcpRequired) {
+        return {
+            wiring: { mcp: 'ok', instructions },
+            mcpRequired: false,
+            notOotb: false,
+            aiderUnsafe: false,
+            message: instructions === 'ok'
+                ? 'Layer 1 instructions present (AGENTS.md).'
+                : 'AGENTS.md is missing the envseal imperative (never read .env; use envseal ensure / envseal run). Run `envseal init`.',
+        };
+    }
+    const inspection = inspectPrimaryMcp(root, hostId, options) ?? {
+        wired: false,
+        status: 'missing',
+        commandOk: null,
+        message: `No project MCP config for host ${hostId}. Run \`envseal init\`.`,
+    };
+    return {
+        wiring: {
+            mcp: mcpWiringState(inspection),
+            instructions,
+        },
+        mcp: inspection,
+        mcpRequired: true,
+        notOotb,
+        aiderUnsafe: false,
+        message: inspection.message,
+    };
+}
+export function wiringFailsDoctor(inspection) {
+    if (inspection.mcpRequired && inspection.wiring.mcp !== 'ok')
+        return true;
+    if (inspection.wiring.instructions === 'missing')
+        return true;
+    if (inspection.aiderUnsafe)
+        return true;
+    return false;
+}
+//# sourceMappingURL=inspect.js.map

package/dist/host-wiring/mcp.d.ts

@@ -0,0 +1,55 @@
+export declare const ENVSEAL_MCP_PACKAGE = "@envseal/mcp-server";
+export declare const ENVSEAL_MCP_SERVER_NAME = "envseal-mcp";
+export declare const NPX_ARGS: readonly ["-y", "@envseal/mcp-server"];
+export type McpLaunch = {
+    command: string;
+    args: string[];
+};
+export type McpWriteAction = 'created' | 'merged' | 'unchanged' | 'skipped';
+export type McpStatus = 'absent' | 'unreadable' | 'missing' | 'stub' | 'wired';
+export type McpInspection = {
+    wired: boolean;
+    status: McpStatus;
+    message: string;
+    /** null when the launch command was not probed (npx is not side-effect free). */
+    commandOk: boolean | null;
+};
+/**
+ * Launch argv a host can spawn without a global `envseal-mcp` on PATH.
+ * Project MCP uses the workspace as cwd — never bake `--project` in.
+ */
+export declare function mcpLaunch(platform?: NodeJS.Platform): McpLaunch;
+export declare function mcpSnippetJson(platform?: NodeJS.Platform): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function argsList(value: unknown): string[] | undefined;
+/** Old shipped stub: `envseal-mcp` with no args. Host launchers do not search node_modules/.bin. */
+export declare function isEmptyEnvsealStub(entry: unknown): boolean;
+/** Our npx snippet, either platform variant, and nothing else in command/args. */
+export declare function isStockNpxLaunch(entry: unknown): boolean;
+/** True when an entry would actually start @envseal/mcp-server (npx or a non-empty command). */
+export declare function looksLikeEnvsealServer(entry: unknown): boolean;
+export declare function nextEnvsealEntry(current: unknown, launch: McpLaunch): McpLaunch | Record<string, unknown> | null;
+export declare function parseJsonObject(text: string): Record<string, unknown> | null;
+export declare function writeJson(path: string, value: unknown): void;
+/**
+ * Merge envseal-mcp into a file whose top-level key is `mcpServers`.
+ * Never writes user-global configs; the caller passes a project path.
+ */
+export declare function mergeMcpServersFile(path: string, platform?: NodeJS.Platform): {
+    action: McpWriteAction;
+    path: string;
+};
+export declare function classifyEntry(entry: unknown): 'missing' | 'stub' | 'wired';
+/**
+ * `--version` is side-effect free on the envseal-mcp binary. `npx -y` is not
+ * (it may hit the network), so the default snippet is not probed.
+ */
+export declare function shouldProbeLaunch(entry: Record<string, unknown>): boolean;
+export declare function probeVersion(entry: Record<string, unknown>): boolean | null;
+export declare function inspectMcpServersFile(path: string, label: string, options?: {
+    probe?: boolean;
+    platform?: NodeJS.Platform;
+}): McpInspection;
+/** Map an inspection to the doctor `agentWiring.mcp` field. */
+export declare function mcpWiringState(inspection: McpInspection): 'ok' | 'missing' | 'spawn_failed';
+//# sourceMappingURL=mcp.d.ts.map

package/dist/host-wiring/mcp.js

@@ -0,0 +1,238 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { spawnSync } from 'node:child_process';
+export const ENVSEAL_MCP_PACKAGE = '@envseal/mcp-server';
+export const ENVSEAL_MCP_SERVER_NAME = 'envseal-mcp';
+export const NPX_ARGS = ['-y', ENVSEAL_MCP_PACKAGE];
+/**
+ * Launch argv a host can spawn without a global `envseal-mcp` on PATH.
+ * Project MCP uses the workspace as cwd — never bake `--project` in.
+ */
+export function mcpLaunch(platform = process.platform) {
+    return {
+        command: platform === 'win32' ? 'npx.cmd' : 'npx',
+        args: [...NPX_ARGS],
+    };
+}
+export function mcpSnippetJson(platform = process.platform) {
+    const launch = mcpLaunch(platform);
+    return JSON.stringify({
+        mcpServers: { [ENVSEAL_MCP_SERVER_NAME]: launch },
+    });
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function argsList(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string'))
+        return undefined;
+    return value;
+}
+/** Old shipped stub: `envseal-mcp` with no args. Host launchers do not search node_modules/.bin. */
+export function isEmptyEnvsealStub(entry) {
+    if (!isRecord(entry))
+        return true;
+    const command = entry.command;
+    if (typeof command !== 'string' || command.trim() === '')
+        return true;
+    if (command !== 'envseal-mcp')
+        return false;
+    const args = argsList(entry.args);
+    return args === undefined || args.length === 0;
+}
+/** Our npx snippet, either platform variant, and nothing else in command/args. */
+export function isStockNpxLaunch(entry) {
+    if (!isRecord(entry))
+        return false;
+    const command = entry.command;
+    if (command !== 'npx' && command !== 'npx.cmd')
+        return false;
+    const args = argsList(entry.args);
+    return (args !== undefined && args.length === NPX_ARGS.length && NPX_ARGS.every((a, i) => a === args[i]));
+}
+/** True when an entry would actually start @envseal/mcp-server (npx or a non-empty command). */
+export function looksLikeEnvsealServer(entry) {
+    if (entry === undefined || isEmptyEnvsealStub(entry))
+        return false;
+    if (!isRecord(entry))
+        return false;
+    const command = entry.command;
+    if (typeof command !== 'string' || command.trim() === '')
+        return false;
+    if (isStockNpxLaunch(entry))
+        return true;
+    const joined = `${command} ${(argsList(entry.args) ?? []).join(' ')}`;
+    return /@envseal\/mcp-server|envseal-mcp/i.test(joined);
+}
+export function nextEnvsealEntry(current, launch) {
+    if (current === undefined || isEmptyEnvsealStub(current)) {
+        return launch;
+    }
+    if (isStockNpxLaunch(current) && isRecord(current)) {
+        if (current.command === launch.command)
+            return null;
+        return { ...current, command: launch.command, args: launch.args };
+    }
+    return null;
+}
+export function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+/**
+ * Merge envseal-mcp into a file whose top-level key is `mcpServers`.
+ * Never writes user-global configs; the caller passes a project path.
+ */
+export function mergeMcpServersFile(path, platform = process.platform) {
+    const launch = mcpLaunch(platform);
+    if (!existsSync(path)) {
+        writeJson(path, { mcpServers: { [ENVSEAL_MCP_SERVER_NAME]: launch } });
+        return { action: 'created', path };
+    }
+    const parsed = parseJsonObject(readFileSync(path, 'utf8'));
+    if (parsed === null) {
+        return { action: 'skipped', path };
+    }
+    const existingServers = parsed.mcpServers;
+    if (existingServers !== undefined && !isRecord(existingServers)) {
+        return { action: 'skipped', path };
+    }
+    const servers = existingServers === undefined ? {} : { ...existingServers };
+    const next = nextEnvsealEntry(servers[ENVSEAL_MCP_SERVER_NAME], launch);
+    if (next === null) {
+        return { action: 'unchanged', path };
+    }
+    servers[ENVSEAL_MCP_SERVER_NAME] = next;
+    writeJson(path, { ...parsed, mcpServers: servers });
+    return { action: 'merged', path };
+}
+export function classifyEntry(entry) {
+    if (entry === undefined)
+        return 'missing';
+    if (isEmptyEnvsealStub(entry))
+        return 'stub';
+    if (!isRecord(entry))
+        return 'stub';
+    const command = entry.command;
+    if (typeof command !== 'string' || command.trim() === '')
+        return 'stub';
+    return 'wired';
+}
+/**
+ * `--version` is side-effect free on the envseal-mcp binary. `npx -y` is not
+ * (it may hit the network), so the default snippet is not probed.
+ */
+export function shouldProbeLaunch(entry) {
+    const command = entry.command;
+    if (typeof command !== 'string')
+        return false;
+    if (command === 'npx' || command === 'npx.cmd')
+        return false;
+    return true;
+}
+export function probeVersion(entry) {
+    if (!shouldProbeLaunch(entry))
+        return null;
+    const command = entry.command;
+    if (typeof command !== 'string')
+        return null;
+    const args = argsList(entry.args) ?? [];
+    const result = spawnSync(command, [...args, '--version'], {
+        encoding: 'utf8',
+        timeout: 5000,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error)
+        return false;
+    if (result.status !== 0)
+        return false;
+    const out = `${result.stdout ?? ''}${result.stderr ?? ''}`;
+    return /envseal-mcp/i.test(out);
+}
+function initHint(platform, label) {
+    return `Run \`envseal init\` to write it, or merge ${mcpSnippetJson(platform)} into ${label}.`;
+}
+export function inspectMcpServersFile(path, label, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const hint = initHint(platform, label);
+    if (!existsSync(path)) {
+        return {
+            wired: false,
+            status: 'absent',
+            commandOk: null,
+            message: `${label} is missing. ${hint}`,
+        };
+    }
+    const parsed = parseJsonObject(readFileSync(path, 'utf8'));
+    if (parsed === null) {
+        return {
+            wired: false,
+            status: 'unreadable',
+            commandOk: null,
+            message: `${label} is not valid JSON. ${hint}`,
+        };
+    }
+    const servers = parsed.mcpServers;
+    if (servers === undefined || (isRecord(servers) && Object.keys(servers).length === 0)) {
+        return {
+            wired: false,
+            status: 'missing',
+            commandOk: null,
+            message: `${label} has no envseal-mcp (empty mcpServers). ${hint}`,
+        };
+    }
+    if (!isRecord(servers)) {
+        return {
+            wired: false,
+            status: 'unreadable',
+            commandOk: null,
+            message: `${label} mcpServers is not an object. ${hint}`,
+        };
+    }
+    const entry = servers[ENVSEAL_MCP_SERVER_NAME];
+    const kind = classifyEntry(entry);
+    if (kind === 'missing') {
+        return {
+            wired: false,
+            status: 'missing',
+            commandOk: null,
+            message: `${label} has no envseal-mcp. ${hint}`,
+        };
+    }
+    if (kind === 'stub') {
+        return {
+            wired: false,
+            status: 'stub',
+            commandOk: null,
+            message: `${label} envseal-mcp is the empty envseal-mcp stub (not on PATH for the host). ${hint}`,
+        };
+    }
+    const rec = entry;
+    const commandOk = options.probe === true ? probeVersion(rec) : null;
+    let message = `MCP is wired (${label}).`;
+    if (commandOk === false) {
+        message = `MCP is configured in ${label}, but the launch command did not report a version. Run \`envseal init\` if the host cannot connect.`;
+    }
+    return { wired: true, status: 'wired', commandOk, message };
+}
+/** Map an inspection to the doctor `agentWiring.mcp` field. */
+export function mcpWiringState(inspection) {
+    if (inspection.commandOk === false)
+        return 'spawn_failed';
+    if (inspection.wired)
+        return 'ok';
+    return 'missing';
+}
+//# sourceMappingURL=mcp.js.map

package/dist/host-wiring/zed.d.ts

@@ -0,0 +1,10 @@
+import { type McpInspection, type McpWriteAction } from './mcp.js';
+export declare function mergeZedSettings(root: string, platform?: NodeJS.Platform): {
+    action: McpWriteAction;
+    path: string;
+};
+export declare function inspectZedSettings(root: string, options?: {
+    probe?: boolean;
+    platform?: NodeJS.Platform;
+}): McpInspection;
+//# sourceMappingURL=zed.d.ts.map

package/dist/host-wiring/zed.js

@@ -0,0 +1,97 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ENVSEAL_MCP_SERVER_NAME, isRecord, mcpLaunch, nextEnvsealEntry, parseJsonObject, writeJson, classifyEntry, probeVersion, } from './mcp.js';
+function zedHint(platform) {
+    const launch = mcpLaunch(platform);
+    return `Run \`envseal init\` to merge { "mcp": { "${ENVSEAL_MCP_SERVER_NAME}": ${JSON.stringify(launch)} } } into .zed/settings.json. [VERIFY]`;
+}
+export function mergeZedSettings(root, platform = process.platform) {
+    const path = join(root, '.zed', 'settings.json');
+    const launch = mcpLaunch(platform);
+    if (!existsSync(path)) {
+        writeJson(path, { mcp: { [ENVSEAL_MCP_SERVER_NAME]: launch } });
+        return { action: 'created', path };
+    }
+    const parsed = parseJsonObject(readFileSync(path, 'utf8'));
+    if (parsed === null) {
+        return { action: 'skipped', path };
+    }
+    const existingMcp = parsed.mcp;
+    if (existingMcp !== undefined && !isRecord(existingMcp)) {
+        return { action: 'skipped', path };
+    }
+    const mcp = existingMcp === undefined ? {} : { ...existingMcp };
+    const next = nextEnvsealEntry(mcp[ENVSEAL_MCP_SERVER_NAME], launch);
+    if (next === null) {
+        return { action: 'unchanged', path };
+    }
+    mcp[ENVSEAL_MCP_SERVER_NAME] = next;
+    writeJson(path, { ...parsed, mcp });
+    return { action: 'merged', path };
+}
+export function inspectZedSettings(root, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const path = join(root, '.zed', 'settings.json');
+    const hint = zedHint(platform);
+    if (!existsSync(path)) {
+        return {
+            wired: false,
+            status: 'absent',
+            commandOk: null,
+            message: `.zed/settings.json is missing. ${hint}`,
+        };
+    }
+    const parsed = parseJsonObject(readFileSync(path, 'utf8'));
+    if (parsed === null) {
+        return {
+            wired: false,
+            status: 'unreadable',
+            commandOk: null,
+            message: `.zed/settings.json is not valid JSON. ${hint}`,
+        };
+    }
+    const mcp = parsed.mcp;
+    if (mcp === undefined || (isRecord(mcp) && Object.keys(mcp).length === 0)) {
+        return {
+            wired: false,
+            status: 'missing',
+            commandOk: null,
+            message: `.zed/settings.json has no envseal-mcp under mcp. ${hint}`,
+        };
+    }
+    if (!isRecord(mcp)) {
+        return {
+            wired: false,
+            status: 'unreadable',
+            commandOk: null,
+            message: `.zed/settings.json mcp is not an object. ${hint}`,
+        };
+    }
+    const entry = mcp[ENVSEAL_MCP_SERVER_NAME];
+    const kind = classifyEntry(entry);
+    if (kind === 'missing') {
+        return {
+            wired: false,
+            status: 'missing',
+            commandOk: null,
+            message: `.zed/settings.json has no envseal-mcp. ${hint}`,
+        };
+    }
+    if (kind === 'stub') {
+        return {
+            wired: false,
+            status: 'stub',
+            commandOk: null,
+            message: `.zed/settings.json envseal-mcp is the empty stub. ${hint}`,
+        };
+    }
+    const rec = entry;
+    const commandOk = options.probe === true ? probeVersion(rec) : null;
+    let message = 'Zed MCP is wired (project .zed/settings.json). [VERIFY: schema]';
+    if (commandOk === false) {
+        message =
+            'Zed MCP is configured, but the launch command did not report a version. Run `envseal init`. [VERIFY]';
+    }
+    return { wired: true, status: 'wired', commandOk, message };
+}
+//# sourceMappingURL=zed.js.map

package/dist/host.d.ts

@@ -6,5 +6,33 @@ export interface HostInfo {
     reason: string;
     recommendation: string;
 }
+/** Host ids `init --host` accepts. `openhands` is Layer 1 only. */
+export declare const KNOWN_HOST_IDS: readonly ["claude-code", "cursor", "continue", "aider", "windsurf", "cline", "zed", "codex", "jetbrains", "goose", "copilot", "generic", "unknown", "openhands"];
+export type HostId = (typeof KNOWN_HOST_IDS)[number];
+export declare function aiderMarkerExists(root: string): boolean;
+export declare function copilotSettingsExist(root: string): boolean;
+/**
+ * Every project-local host marker in this repo. Used by `init` so a dual-host
+ * tree (`.cursor/` + `.claude/`) gets both configs. Does not include AGENTS.md
+ * (Layer 1 is always applied) and does not scan `$HOME`.
+ */
+export declare function collectProjectHostIds(root: string): string[];
+/**
+ * This-process host only. Used by `init` when the project has no markers.
+ * Never treats a global `~/.cursor` / `~/.codex` install as this project.
+ */
+export declare function detectProcessHostId(): string | undefined;
+export declare function parseHostOverride(raw: string): string[] | {
+    error: string;
+};
+/**
+ * Which hosts `init` should write Layer 2 config for.
+ * `--host` is an escape hatch (comma-separated ok). Never crawls `$HOME`.
+ */
+export declare function resolveInitHostIds(root: string, hostOverride?: string): {
+    ids: string[];
+    source: 'flag' | 'project' | 'process' | 'none';
+    error?: string;
+};
 export declare function detectHost(root: string): HostInfo;
 //# sourceMappingURL=host.d.ts.map