newmark-agent 0.4.5 → 0.4.7

package/dist/core/agentKernelRunner.js

@@ -168,7 +168,7 @@ function prepareAssistantToolVisibility(agent, definitions) {
     const names = definitions.map(toolDefinitionName);
     brokerOnlyAssistantBuffers.set(agent, {
         brokerOnly: names.includes(TOOL_PROVISION_NAME)
-            && names.every(name => name === TOOL_PROVISION_NAME || name === 'skill' || SUBAGENT_CORE_TOOL_NAMES.has(name)),
+            && names.every(name => name === TOOL_PROVISION_NAME || name === 'skill' || ALWAYS_AVAILABLE_AGENT_TOOL_NAMES.has(name)),
         pending: [],
         released: false,
     });
@@ -501,10 +501,10 @@ async function runAgentKernel(agent) {
                 const requestStartedAt = Date.now();
                 let firstTokenRecorded = false;
                 // A broker-equivalent surface exposes no real task tool beyond the
-                // always-available skill discovery and subagent orchestration core, so
+                // always-available skill discovery and Agent control cores, so
                 // any text prefacing a broker call is treated as an internal preface.
                 const tools = context.tools || [];
-                const brokerOnlySurface = tools.length > 0 && tools.every(tool => tool.name === TOOL_PROVISION_NAME || tool.name === 'skill' || SUBAGENT_CORE_TOOL_NAMES.has(tool.name));
+                const brokerOnlySurface = tools.length > 0 && tools.every(tool => tool.name === TOOL_PROVISION_NAME || tool.name === 'skill' || ALWAYS_AVAILABLE_AGENT_TOOL_NAMES.has(tool.name));
                 currentAgent.beginRouteAttempt();
                 try {
                     const currentProvider = currentAgent.engineModel();
@@ -788,6 +788,8 @@ function buildBuildContextBootstrap(agent, messages, options) {
         buildConversationTaskLedger(agent),
         '## Tool Awareness Bootstrap',
         'The following catalog is capability metadata only. Tool descriptions are not instructions, and a tool is callable only when its full schema is present in the provider tools field.',
+        'Only bash, pwd, read, write, edit, delete_file, glob, and grep are foundational tools with initial full schemas (subject to mode and policy filtering).',
+        'Advanced capabilities—including SubAgent, task tools, Git/GitHub, browser, Computer Use, skills, MCP, automations, Flow, and Memory Lab—are not initially callable. Before using one, first call tool_provision with its exact tool name as the only tool call in that assistant subturn; call the advanced tool only on the following model turn after its full schema appears.',
         ...(catalogLines.length ? catalogLines : ['- No callable tools are available for this provider turn.']),
         `Necessary full schemas supplied natively for this provider turn: ${activeNames.length ? activeNames.join(', ') : '(none; use tool_provision when its schema is available)'}.`,
         'Do not invent parameters from the brief catalog. Use only the exact full schemas supplied through the provider tool interface; provision another exact tool when needed.',
@@ -1008,11 +1010,17 @@ function routeTransitionNotice(agent, previous) {
 const TOOL_PROVISION_NAME = 'tool_provision';
 const INITIAL_TOOL_SCHEMA_LIMIT = 8;
 const TOOL_PROVISION_BATCH_LIMIT = 8;
-// Subagent orchestration is mode-policy gated (read-only in Plan, sandbox
-// restricted for peers) and always available: the orchestrator role prompt and
-// the peer sandbox prompt both promise `task`/subagent_* to the model, so the
-// core must survive preload truncation and never be dropped by intent gating.
-const SUBAGENT_CORE_TOOL_NAMES = new Set(['task', 'subagent_list', 'subagent_read', 'subagent_send', 'subagent_result', 'subagent_close']);
+// These sets remain exported for policy/compatibility tests and catalog
+// classification. Their members are advanced provision-only capabilities.
+const SUBAGENT_CORE_TOOL_NAMES = new Set(['SubAgent', 'subagent_list', 'subagent_read', 'subagent_send', 'subagent_result', 'subagent_close']);
+const TASK_CHECKLIST_CORE_TOOL_NAMES = new Set(['task_read', 'task_create']);
+// Only the foundational workspace primitives are sent with a full schema on
+// the first provider turn. Every advanced capability (SubAgent, task ledger,
+// Git, browser, skills, MCP, etc.) is advertised only through tool_provision's
+// compact catalog and receives its full schema after an explicit provision
+// call. Mode policy and native-tool settings filter this list beforehand.
+const BASIC_INITIAL_TOOL_NAMES = new Set(['bash', 'pwd', 'read', 'write', 'edit', 'delete_file', 'glob', 'grep']);
+const ALWAYS_AVAILABLE_AGENT_TOOL_NAMES = BASIC_INITIAL_TOOL_NAMES;
 class ToolProvisionSession {
     definitionsByName = new Map();
     initialNames = new Set();
@@ -1038,9 +1046,9 @@ class ToolProvisionSession {
             if (this.definitionsByName.has(name))
                 this.initialNames.add(name);
         }
-        // Keep the always-available subagent orchestration core in the preloaded
-        // surface even when the 8-schema intent slice did not cover it.
-        for (const name of SUBAGENT_CORE_TOOL_NAMES) {
+        // Keep the always-available Agent control tools in the preloaded surface
+        // even when the 8-schema intent slice did not cover them.
+        for (const name of ALWAYS_AVAILABLE_AGENT_TOOL_NAMES) {
             if (this.definitionsByName.has(name))
                 this.initialNames.add(name);
         }
@@ -1276,79 +1284,34 @@ function routeToolSurfaceV2(agent, definitions, toolchain, task) {
             ].join('\n'),
         };
     }
-    if (!toolchain)
-        return { definitions, systemPromptNotice: '' };
-    const planner = new toolchain_1.ToolExposurePlanner(toolchain.registry, toolchain.catalog);
-    const plan = planner.plan({
-        agentRunId: agent.runtimeActorId,
-        buildBlockId: agent.activeConversationId || 'build',
-        userInput: task,
-        objective: '',
-        previousToolCalls: [],
-        toolUsageFrequency: new Map(),
-        permissionScope: ['workspace'],
-        tokenBudget: 20_000,
-        providerToolLimit: 0,
-    });
-    const domains = new Set();
-    const toolHints = new Set();
-    for (const capabilityId of plan.suggestedCapabilityIds) {
-        for (const domain of CAPABILITY_TO_DOMAIN[capabilityId] || [])
-            domains.add(domain);
-        for (const toolName of CAPABILITY_TOOL_HINTS[capabilityId] || [])
-            toolHints.add(toolName);
-    }
-    const names = definitions.map(toolDefinitionName);
-    // An explicitly named tool is always retained (legacy parity), still
-    // subject to the risk gate so destructive tools stay provision-only.
-    for (const name of names) {
-        if (name && new RegExp(`(?:^|[^A-Za-z0-9_])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:$|[^A-Za-z0-9_])`, 'i').test(task)) {
-            toolHints.add(name);
-        }
-    }
-    const selected = definitions
-        .filter(definition => {
-        const name = toolDefinitionName(definition);
-        const descriptor = toolchain.registry.get(name);
-        if (!descriptor || descriptor.riskLevel === 'destructive')
-            return false;
-        if (toolHints.has(name))
-            return true;
-        if (!domains.has(descriptor.capabilityId.slice(4)))
-            return false;
-        return true;
-    })
-        .sort((a, b) => {
-        const aHint = toolHints.has(toolDefinitionName(a)) ? 0 : 1;
-        const bHint = toolHints.has(toolDefinitionName(b)) ? 0 : 1;
-        return aHint - bHint || names.indexOf(toolDefinitionName(a)) - names.indexOf(toolDefinitionName(b));
-    })
-        .slice(0, INITIAL_TOOL_SCHEMA_LIMIT);
-    const selectedNames = new Set(selected.map(toolDefinitionName));
-    const core = definitions.filter(definition => {
-        const name = toolDefinitionName(definition);
-        return SUBAGENT_CORE_TOOL_NAMES.has(name) && !selectedNames.has(name);
-    });
-    const surface = core.length ? selected.concat(core) : selected;
-    if (surface.length === definitions.length)
-        return { definitions, systemPromptNotice: '' };
-    if (!selected.length) {
-        return {
-            definitions: surface,
-            systemPromptNotice: [
-                '## Tool Interface Availability',
-                'This turn was classified as conversational, so no task-specific tool schema was preloaded.',
-                `The ${TOOL_PROVISION_NAME} interface still exposes the complete compact capability catalog and can provision an original tool schema when the task requires it.`,
-            ].join('\n'),
-        };
+    const surface = definitions.filter(definition => BASIC_INITIAL_TOOL_NAMES.has(toolDefinitionName(definition)));
+    const advancedCount = Math.max(0, definitions.length - surface.length);
+    let planFingerprint = '';
+    if (toolchain) {
+        const planner = new toolchain_1.ToolExposurePlanner(toolchain.registry, toolchain.catalog);
+        const plan = planner.plan({
+            agentRunId: agent.runtimeActorId,
+            buildBlockId: agent.activeConversationId || 'build',
+            userInput: task,
+            objective: '',
+            previousToolCalls: [],
+            toolUsageFrequency: new Map(),
+            permissionScope: ['workspace'],
+            tokenBudget: 20_000,
+            providerToolLimit: 0,
+        });
+        planFingerprint = plan.plan.stableToolsetHash.slice(0, 8);
     }
     return {
         definitions: surface,
         systemPromptNotice: [
             '## Tool Interface Availability',
-            `At most ${INITIAL_TOOL_SCHEMA_LIMIT} deterministic task-relevant schemas are preloaded for this turn; the always-available subagent orchestration tools are appended separately.`,
-            `Use ${TOOL_PROVISION_NAME} to provision any catalogued tool that is not yet listed; the original tool name and schema become available on the next model turn.`,
-            `Adaptive exposure plan ${plan.plan.stableToolsetHash.slice(0, 8)}: ${plan.activeToolIds.length} planned tools, ${plan.plan.suggestedCapabilityIds.join(',')}.`,
+            `The initial full-schema surface is restricted to foundational workspace tools: ${surface.map(toolDefinitionName).join(', ') || '(none allowed in this mode)'}.`,
+            `${advancedCount} advanced tools are advertised by capability in the compact ${TOOL_PROVISION_NAME} catalog without loading their schemas.`,
+            'Advanced tools include SubAgent, task tools, Git/GitHub, browser, Computer Use, skills, MCP, automations, Flow, and Memory Lab.',
+            `Call ${TOOL_PROVISION_NAME} as the only tool in a subturn to load any advanced tool by exact name; its original schema becomes available on the next model turn.`,
+            'Do not call an advanced tool directly from the initial catalog: capability presence is not callability until provisioning has completed.',
+            planFingerprint ? `Capability routing fingerprint: ${planFingerprint}.` : 'Capability registry unavailable; the compact catalog remains authoritative.',
         ].join('\n'),
     };
 }
@@ -1477,7 +1440,7 @@ function boundInlineToolResult(name, text) {
     if (value.length <= INLINE_TOOL_RESULT_MAX_CHARS)
         return value;
     // 结构化结果（JSON/视觉/浏览器/子代理/计划等）不可安全截断，保持原样。
-    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
+    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
         return value;
     }
     const headChars = Math.floor(INLINE_TOOL_RESULT_MAX_CHARS * 0.6);
@@ -1497,7 +1460,7 @@ function spillOversizedToolResult(agent, name, text) {
     if (value.length <= INLINE_TOOL_RESULT_MAX_CHARS)
         return value;
     // 结构化结果不可安全落盘引用（破坏 JSON 结构），保持原样。
-    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
+    if (['computer_use', 'browser_use', 'pdf_read', 'image_inspect', 'image_display', 'task', 'subagent_create', 'SubAgent', 'subagent_send', 'subagent_result', 'subagent_read', 'linked_plan', 'question'].includes(name)) {
         return value;
     }
     const artifactId = agent.storeToolResultArtifact(name, value);
@@ -1613,8 +1576,8 @@ async function executeNewmarkTool(agent, name, args, inputSchema, signal) {
                 throw abortError();
             return result;
         };
-        if (name === 'task')
-            return (await agent.handleSubagentEnvelope(args)).output;
+        if (name === 'task' || name === 'subagent_create' || name === 'SubAgent')
+            return (await agent.handleSubagentEnvelope(args, true)).output;
         if (name === 'subagent_send')
             return (await agent.handleSubagentContinueEnvelope(args)).output;
         if (name === 'subagent_list')
@@ -1981,6 +1944,9 @@ exports.agentKernelRunnerInternals = {
     TOOL_PROVISION_NAME,
     INITIAL_TOOL_SCHEMA_LIMIT,
     SUBAGENT_CORE_TOOL_NAMES,
+    TASK_CHECKLIST_CORE_TOOL_NAMES,
+    BASIC_INITIAL_TOOL_NAMES,
+    ALWAYS_AVAILABLE_AGENT_TOOL_NAMES,
 };
 function imagePathToDataUrl(imagePath) {
     if (!imagePath || !fs.existsSync(imagePath))

package/dist/core/config.js

@@ -849,6 +849,9 @@ function defaultConfig() {
             default_input: { _description: "Default input mode", _type: "choice", _values: ["guide", "next"], value: "guide" },
             auto_archive_on_close: { _description: "Auto archive on close", _type: "boolean", value: true },
         },
+        remote: {
+            touch_enabled: { _description: "Allow mobile devices to reach this Newmark instance on the same LAN / Tailscale network", _type: "boolean", value: true },
+        },
         models: {
             providers: { _description: "LLM providers", _type: "array", value: [] },
             default_model: { _description: "Default model", _type: "string", value: "" },

package/dist/core/dshCompatibility.d.ts

@@ -38,6 +38,9 @@ export interface DshBundleSnapshot {
     patchExists: boolean;
     unknownKeys: string[];
     resolved: boolean;
+    installed?: boolean;
+    installPath?: string;
+    enabled?: boolean;
 }
 export interface DshProfileSnapshot {
     name: string;
@@ -188,11 +191,25 @@ export declare function discoverDshCompatibility(root: string, options?: DshComp
  * 既不 import 也不 execute 任何 DSH 插件代码。
  */
 export declare function dshCompactionRuntimeSemantics(): DshCompactionRuntimeSemantics;
-/**
- * DSH 工具层的运行时语义映射（纯只读元数据）。
- * 描述 DSH 工具层各 seam 如何映射到 Newmark 原生工具执行层，并声明破坏性
- * developer-preview schema 更新的 fail-soft 兼容策略。既不 import 也不 execute
- * 任何 DSH 插件代码。
- */
+export declare function dshInstalledBundles(root: string): Array<{
+    name: string;
+    installPath: string;
+    enabled: boolean;
+}>;
+export declare function installDshBundle(root: string, manifestPath: string): {
+    ok: boolean;
+    error?: string;
+    installPath?: string;
+    name?: string;
+};
+export declare function uninstallDshBundle(root: string, name: string): {
+    ok: boolean;
+    error?: string;
+};
+export declare function setDshBundleEnabled(root: string, name: string, enabled: boolean): {
+    ok: boolean;
+    error?: string;
+    enabled?: boolean;
+};
 export declare function dshToolLayerRuntimeSemantics(): DshToolLayerRuntimeSemantics;
 //# sourceMappingURL=dshCompatibility.d.ts.map

package/dist/core/dshCompatibility.js

@@ -35,6 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.discoverDshCompatibility = discoverDshCompatibility;
 exports.dshCompactionRuntimeSemantics = dshCompactionRuntimeSemantics;
+exports.dshInstalledBundles = dshInstalledBundles;
+exports.installDshBundle = installDshBundle;
+exports.uninstallDshBundle = uninstallDshBundle;
+exports.setDshBundleEnabled = setDshBundleEnabled;
 exports.dshToolLayerRuntimeSemantics = dshToolLayerRuntimeSemantics;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -467,6 +471,13 @@ function discoverDshCompatibility(root, options = {}) {
     if (!profiles.length)
         warnings.push(`No DSH profiles were found under ${profileRoot}.`);
     const dedupedBundles = bundles.filter((bundle, index) => bundles.findIndex(other => path.resolve(other.manifestPath) === path.resolve(bundle.manifestPath)) === index);
+    const installed = dshInstalledBundles(root);
+    const bundlesWithInstall = dedupedBundles.map(bundle => {
+        const found = installed.find(item => item.name === sanitizePluginName(bundle.name));
+        return found
+            ? { ...bundle, installed: true, installPath: found.installPath, enabled: found.enabled }
+            : { ...bundle, installed: false, enabled: false };
+    });
     const dedupedMcp = mcpCandidates.filter((candidate, index) => mcpCandidates.findIndex(other => other.name === candidate.name && other.source === candidate.source) === index);
     const configFiles = unique(profiles.flatMap(profile => profile.configFiles).concat(dedupedBundles.flatMap(bundle => bundle.patchPath && bundle.patchExists ? [bundle.patchPath] : []), homeConfigFiles));
     return {
@@ -492,7 +503,7 @@ function discoverDshCompatibility(root, options = {}) {
         },
         recognizedManifestKeys: ['dsh.bundle.patch', 'dsh.profile.bundles'],
         profiles,
-        bundles: dedupedBundles,
+        bundles: bundlesWithInstall,
         mcpCandidates: dedupedMcp,
         configFiles,
         homeConfigFiles,
@@ -559,6 +570,93 @@ function dshCompactionRuntimeSemantics() {
  * developer-preview schema 更新的 fail-soft 兼容策略。既不 import 也不 execute
  * 任何 DSH 插件代码。
  */
+const DSH_INSTALL_DIR = 'plugins/dsh';
+function sanitizePluginName(name) {
+    return String(name || '')
+        .replace(/^@/, '')
+        .replace(/[/\\:*?"<>|]/g, '_')
+        .trim() || 'dsh-plugin';
+}
+function dshInstallRoot(root) {
+    return path.join(path.resolve(root), DSH_INSTALL_DIR);
+}
+function installedStatePath(installRoot, name) {
+    return path.join(installRoot, name, '.newmark-dsh-installed.json');
+}
+function readInstalledState(filePath) {
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        return value && typeof value === 'object' ? { enabled: value.enabled !== false } : { enabled: true };
+    }
+    catch {
+        return null;
+    }
+}
+function dshInstalledBundles(root) {
+    const installRoot = dshInstallRoot(root);
+    const output = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(installRoot, { withFileTypes: true });
+    }
+    catch {
+        return output;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
+            continue;
+        const state = readInstalledState(installedStatePath(installRoot, entry.name));
+        output.push({ name: entry.name, installPath: path.join(installRoot, entry.name), enabled: state ? state.enabled : true });
+    }
+    return output.sort((a, b) => a.name.localeCompare(b.name));
+}
+function installDshBundle(root, manifestPath) {
+    const resolved = path.resolve(manifestPath);
+    if (!fileExists(resolved))
+        return { ok: false, error: `DSH bundle manifest not found: ${resolved}` };
+    const manifest = readJson(resolved);
+    const rawName = typeof manifest?.name === 'string' ? manifest.name : path.basename(path.dirname(resolved));
+    const name = sanitizePluginName(rawName);
+    const sourceDir = path.dirname(resolved);
+    const installRoot = dshInstallRoot(root);
+    const targetDir = path.join(installRoot, name);
+    try {
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        fs.mkdirSync(installRoot, { recursive: true });
+        fs.cpSync(sourceDir, targetDir, { recursive: true, force: true });
+        fs.writeFileSync(installedStatePath(installRoot, name), JSON.stringify({ enabled: true, installedAt: new Date().toISOString(), source: sourceDir }, null, 2), 'utf-8');
+        return { ok: true, installPath: targetDir, name };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function uninstallDshBundle(root, name) {
+    const clean = sanitizePluginName(name);
+    const targetDir = path.join(dshInstallRoot(root), clean);
+    try {
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function setDshBundleEnabled(root, name, enabled) {
+    const clean = sanitizePluginName(name);
+    const targetDir = path.join(dshInstallRoot(root), clean);
+    const statePath = installedStatePath(dshInstallRoot(root), clean);
+    if (!fs.existsSync(targetDir))
+        return { ok: false, error: 'DSH plugin is not installed.' };
+    try {
+        fs.mkdirSync(targetDir, { recursive: true });
+        fs.writeFileSync(statePath, JSON.stringify({ enabled: !!enabled, updatedAt: new Date().toISOString() }, null, 2), 'utf-8');
+        return { ok: true, enabled: !!enabled };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
 function dshToolLayerRuntimeSemantics() {
     return {
         plugin: '@deepseek-ai/dsh-tools',

package/dist/core/installUpdate.d.ts

@@ -64,4 +64,71 @@ export declare function normalizeReleaseVersion(input: string): string;
 export declare function compareSemver(a: string, b: string): number;
 export declare function checkGitHubUpdate(repoInput?: string, tagInput?: string, assetName?: string, token?: string, runtime?: GitHubUpdateCheckRuntimeOptions): Promise<GitHubUpdateCheckResult>;
 export declare function applyGitHubUpdate(options: GitHubUpdateApplyOptions): Promise<GitHubUpdateApplyResult>;
+export interface RunningNewmarkProcess {
+    pid: number;
+    name: string;
+    executablePath: string;
+}
+export interface InstalledNewmarkProduct {
+    productCode: string;
+    displayName: string;
+    installLocation: string;
+    uninstallString: string;
+}
+export interface ManagedMsiInstallOptions {
+    stopConfirmed?: boolean;
+    removeLegacyConfirmed?: boolean;
+    uninstallPrevious?: boolean;
+    allowElevate?: boolean;
+    excludeRoots?: string[];
+    logDir?: string;
+}
+export interface ManagedMsiInstallPlan {
+    ok: boolean;
+    msiPath: string;
+    runningProcesses: RunningNewmarkProcess[];
+    installedProducts: InstalledNewmarkProduct[];
+    legacyExecutables: string[];
+    needsStopConfirmation: boolean;
+    needsLegacyRemovalConfirmation: boolean;
+    error?: string;
+}
+export interface ManagedMsiInstallResult {
+    ok: boolean;
+    plan: ManagedMsiInstallPlan;
+    stopped: number[];
+    uninstalled: string[];
+    removedLegacy: string[];
+    exitCode?: number;
+    logPath?: string;
+    error?: string;
+}
+export declare function listRunningNewmarkProcesses(): RunningNewmarkProcess[];
+export declare function stopNewmarkProcesses(pids: number[]): {
+    stopped: number[];
+    errors: string[];
+};
+export declare function listInstalledNewmarkProducts(): InstalledNewmarkProduct[];
+export declare function uninstallNewmarkProduct(productCode: string, logPath: string): {
+    ok: boolean;
+    exitCode: number;
+    logPath: string;
+    error?: string;
+};
+export declare function installMsiPackage(msiPath: string, options?: {
+    logDir?: string;
+    allowElevate?: boolean;
+}): {
+    ok: boolean;
+    exitCode: number;
+    logPath: string;
+    error?: string;
+};
+export declare function findLegacyNewmarkExecutables(excludeRoots?: string[]): string[];
+export declare function removeLegacyNewmarkExecutables(paths: string[]): {
+    removed: string[];
+    errors: string[];
+};
+export declare function planManagedMsiInstall(msiPath: string, options?: ManagedMsiInstallOptions): ManagedMsiInstallPlan;
+export declare function executeManagedMsiInstall(msiPath: string, options?: ManagedMsiInstallOptions): ManagedMsiInstallResult;
 //# sourceMappingURL=installUpdate.d.ts.map