@agilemonster/mcp-server 1.0.24 → 1.0.26

package/dist/server.js

@@ -8,13 +8,30 @@ import { spawn, execSync, execFileSync } from 'node:child_process';
 import { isUtf8 } from 'node:buffer';
 import { fileURLToPath } from 'node:url';
 import { AgileMonsterClient, MCP_SERVER_VERSION, isClaimConflict } from './client.js';
+import { machineReport } from './machine.js';
+import { managedRunnerDir, updateArgs } from './service.js';
 import { AGENT_GUIDELINES_MARKDOWN } from './guidelines.js';
 import { knownSecrets, redactResult } from './redact.js';
 import { describeProfile, methodLabel, normalizeMethod, resolveDeployProfile, trustBoundRoute, } from './deploy-profile.js';
 import { addPendingVerification, getCardState, loadMemory, recordAttempt, removePendingVerification, setCardState, setExplicitProfile, } from './deploy-memory.js';
 import { checkCiOnce, describeFailureForHuman, ensureLocalGitExcludes, parseDeployDirective, runDeployment, } from './deploy-runner.js';
-import { baselineFor, buildAgentPrompt, changesSince, clearBaseline, engineLabelFor, markNewFilesForDiff, parseAgentReport, proseOf, resolveEngines, restoreWorkingTree, runEngine, } from './agent-engine.js';
+import { baselineFor, buildAgentPrompt, changesSince, clearBaseline, engineLabelFor, engineStatuses, markNewFilesForDiff, parseAgentReport, proseOf, resolveEngines, restoreWorkingTree, runEngine, } from './agent-engine.js';
 import { addWellKnownToolDirs, agileMonsterHome, configureLogger, ensureUserPath, errorMessage, exec, log, readJson, which, writeJsonAtomic, } from './runtime.js';
+/**
+ * The answers a deploy question accepts, as reply buttons: nobody should have to type `deploy: ./deploy.sh`.
+ * A first-time route gets "yes, this way" and "I deploy it myself"; a failure gets "try again".
+ */
+export function deployReplyOptions(res) {
+    if (res.errorKind === 'needs_confirmation') {
+        const route = (res.command || res.method || '').trim();
+        const options = [];
+        if (route)
+            options.push({ label: 'Yes, deploy this way', reply: `deploy: ${route}` });
+        options.push({ label: 'I deploy it myself', reply: 'deploy: manual' });
+        return options;
+    }
+    return [{ label: 'Try again', reply: 'retry' }];
+}
 export function createServer(client = new AgileMonsterClient()) {
     const server = new Server({
         name: 'agilemonster-mcp-server',
@@ -263,6 +280,11 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                         type: 'string',
                         description: 'The question for the user.',
                     },
+                    options: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Optional: up to four short answers the user can pick with one tap. The card shows them as buttons, and the user can still type a different answer.',
+                    },
                 },
                 required: ['card_id', 'provider', 'question'],
             },
@@ -640,7 +662,10 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const cardId = args.card_id;
                     const provider = args.provider || projectConfig?.provider || 'antigravity';
                     const question = args.question;
-                    const card = await client.askQuestion(cardId, provider, question);
+                    const answers = Array.isArray(args.options)
+                        ? args.options.map((o) => String(o).trim()).filter((o) => o.length > 0 && o.length <= 80).slice(0, 4)
+                        : [];
+                    const card = await client.askQuestion(cardId, provider, question, answers);
                     releaseClaim(cardId);
                     return {
                         content: [
@@ -1015,11 +1040,16 @@ function triggerBackgroundSelfUpdate(targetVersion) {
                 catch { }
             }
         }
-        // 2. Install @agilemonster/mcp-server@latest into global/npx cache, then exit once idle so launchd respawns the daemon
-        const child = spawn('sh', ['-c', 'npm install -g @agilemonster/mcp-server@latest >/dev/null 2>&1 || npx -y @agilemonster/mcp-server@latest --version >/dev/null 2>&1'], {
-            stdio: 'ignore',
-            detached: true,
-        });
+        // 2. Fetch the new version, then exit once idle so launchd/systemd starts it. The background service
+        // updates its own copy in place; a runner started any other way refreshes the global install / npx cache.
+        const ownDir = managedRunnerDir(fileURLToPath(import.meta.url));
+        const npm = which('npm');
+        const child = ownDir && npm
+            ? spawn(npm, updateArgs(ownDir), { stdio: 'ignore', detached: true, cwd: ownDir })
+            : spawn('sh', ['-c', 'npm install -g @agilemonster/mcp-server@latest >/dev/null 2>&1 || npx -y @agilemonster/mcp-server@latest --version >/dev/null 2>&1'], {
+                stdio: 'ignore',
+                detached: true,
+            });
         child.on('exit', () => {
             appendIdeActivityLog(cwd, {
                 cardId: 'system-update',
@@ -1579,7 +1609,7 @@ async function runRedeployOnlyCard(client, card, projectPath, provider, workerLa
             pending_confirmation: res.errorKind === 'needs_confirmation' ? { method: res.method, command: res.command } : null,
         }));
         removeTaskLock(lockFile);
-        await client.askQuestion(card.id, provider, res.errorKind === 'needs_confirmation' ? describeFailureForHuman(res) : `The redeploy did not go through.\n\n${describeFailureForHuman(res)}`);
+        await client.askQuestion(card.id, provider, res.errorKind === 'needs_confirmation' ? describeFailureForHuman(res) : `The redeploy did not go through.\n\n${describeFailureForHuman(res)}`, deployReplyOptions(res));
         return false;
     }
     if (res.pending && res.pendingVerification)
@@ -1683,7 +1713,7 @@ async function resumeFailedDeployment(client, card, projectPath, provider, worke
         // Nothing is ever confirmed on the human's behalf.
         removeTaskLock(lockFile);
         setCardState(projectPath, card.id, { ...state, at: new Date().toISOString() });
-        await client.askQuestion(card.id, provider, `I still need an answer before I deploy this project for the first time. Reply \`deploy: ${pendingRoute.command || pendingRoute.method}\` to confirm, \`deploy: manual\` if you deploy it yourself, or tell me the right route.`);
+        await client.askQuestion(card.id, provider, `I still need an answer before I deploy this project for the first time. Reply \`deploy: ${pendingRoute.command || pendingRoute.method}\` to confirm, \`deploy: manual\` if you deploy it yourself, or tell me the right route.`, deployReplyOptions({ errorKind: 'needs_confirmation', method: pendingRoute.method, command: pendingRoute.command }));
         return 'failed';
     }
     // No fresh reply at all: a re-queue of a deploy-failed card means "try the same deployment again".
@@ -1736,7 +1766,7 @@ async function resumeFailedDeployment(client, card, projectPath, provider, worke
         });
         await client.askQuestion(card.id, provider, res.errorKind === 'needs_confirmation'
             ? describeFailureForHuman(res)
-            : `The deployment still did not go through, so this card stays in progress.\n\n${describeFailureForHuman(res)}`);
+            : `The deployment still did not go through, so this card stays in progress.\n\n${describeFailureForHuman(res)}`, deployReplyOptions(res));
         return 'failed';
     }
     if (res.pending && res.pendingVerification) {
@@ -1878,8 +1908,10 @@ async function produceChangeWithAgent(run) {
     const { client, card, projectPath, provider, workerLabel, lockFile, carryOverFiles } = run;
     const { engines, notes } = await resolveEngines(provider);
     run.engineNotes.push(...notes);
-    if (engines.length === 0)
+    if (engines.length === 0) {
+        log.info('agent.unavailable', { card: card.id, provider, notes });
         return 'unavailable';
+    }
     // The agent gets a shell. Like a deploy command, what runs on this machine is for its owner to decide:
     // only cards its owner wrote are handed over (and only the owner's replies were kept in the conversation).
     if (!run.ownerId || !card.created_by || card.created_by !== run.ownerId) {
@@ -1902,7 +1934,7 @@ async function produceChangeWithAgent(run) {
         return files.length > 0;
     };
     run.rollback.fn = async () => revert((await changesSince(projectPath, baseline)).changed);
-    const backToHuman = async (question, summary, files) => {
+    const backToHuman = async (question, summary, files, options = []) => {
         run.rollback.fn = null;
         removeTaskLock(lockFile);
         appendIdeActivityLog(projectPath, {
@@ -1914,9 +1946,10 @@ async function produceChangeWithAgent(run) {
             summary,
             files,
         });
-        await client.askQuestion(card.id, provider, question);
+        await client.askQuestion(card.id, provider, question, options);
         return 'handled';
     };
+    const TRY_AGAIN = [{ label: 'Try again', reply: 'Please try again.' }];
     const prompt = buildAgentPrompt({
         title: card.title || '',
         description: card.description || '',
@@ -1931,8 +1964,14 @@ async function produceChangeWithAgent(run) {
     // 1. Run the first agent that actually starts. One that is logged out or crashes on launch touches nothing.
     let engine = engines[0];
     let result = null;
+    const nativeLabel = engineLabelFor(provider);
     for (const candidate of engines) {
-        await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. **${candidate.label}** is working on it in the project folder — reading, searching, editing and building, as it would in the IDE.`);
+        // A card assigned to Cursor that Codex ends up working must say so, with the one step that fixes it
+        const passedOver = nativeLabel && candidate.label !== nativeLabel ? run.engineNotes.filter((n) => n.startsWith(nativeLabel)) : [];
+        await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. **${candidate.label}** is working on it in the project folder — reading, searching, editing and building, as it would in the IDE.` +
+            (passedOver.length > 0
+                ? `\n\n${candidate.label} is standing in for ${nativeLabel}, which cannot run on this machine yet:\n${passedOver.map((n) => `- ${n}`).join('\n')}`
+                : ''));
         log.info('agent.start', { card: card.id, engine: candidate.id, project: projectPath });
         const attempt = await runEngine(candidate, { prompt, projectPath, model });
         log.info('agent.end', { card: card.id, engine: candidate.id, ok: attempt.ok, seconds: Math.round(attempt.durationMs / 1000), failure: attempt.failure });
@@ -1966,11 +2005,11 @@ async function produceChangeWithAgent(run) {
         await revert(change.changed);
         return backToHuman(`I need to change ${foreign.map((f) => `\`${f}\``).join(', ')}, but ${foreign.length === 1 ? 'that file has' : 'those files have'} uncommitted changes in \`${projectPath}\` that are not mine. Committing my edit would also commit that unfinished work, so I stopped and put everything back.\n\n${started.interrupted
             ? 'An earlier run of this card was interrupted before it finished, so these may be its leftovers rather than your work. If you did not make them, discard them (`git checkout -- <file>`); otherwise commit or stash them. Then reply here and I will continue.'
-            : 'Commit or stash those changes, then reply here and I will continue.'}`, `Stopped: ${foreign.join(', ')} had uncommitted changes`, foreign);
+            : 'Commit or stash those changes, then reply here and I will continue.'}`, `Stopped: ${foreign.join(', ')} had uncommitted changes`, foreign, [{ label: 'Done, continue', reply: 'I committed or stashed those changes. Please continue.' }]);
     }
     if (!result.ok) {
         await revert(change.changed);
-        return backToHuman(`${engine.label} worked on this for ${Math.max(1, Math.round(result.durationMs / 60000))} minute(s) but did not finish: ${result.failure || 'it stopped without a result'}.\n\nI put the files back the way they were. Reply here to have it try again — if the card is large, splitting it into smaller cards helps.`, `${engine.label} did not finish: ${result.failure || 'no result'}`, []);
+        return backToHuman(`${engine.label} worked on this for ${Math.max(1, Math.round(result.durationMs / 60000))} minute(s) but did not finish: ${result.failure || 'it stopped without a result'}.\n\nI put the files back the way they were. Reply here to have it try again — if the card is large, splitting it into smaller cards helps.`, `${engine.label} did not finish: ${result.failure || 'no result'}`, [], TRY_AGAIN);
     }
     let report = parseAgentReport(result.text);
     if (report.status === 'blocked' || change.changed.length === 0) {
@@ -1978,7 +2017,7 @@ async function produceChangeWithAgent(run) {
         const said = report.question || report.summary || proseOf(result.text);
         return backToHuman(report.status === 'blocked' && report.question
             ? report.question
-            : `${engine.label} finished without changing any files.${said ? `\n\n${said}` : ''}\n\nIf something is still missing, reply here with what you expected to change.`, `Needs input: ${said.slice(0, 400)}`, []);
+            : `${engine.label} finished without changing any files.${said ? `\n\n${said}` : ''}\n\nIf something is still missing, reply here with what you expected to change.`, `Needs input: ${said.slice(0, 400)}`, [], report.status === 'blocked' && report.question ? report.options : []);
     }
     // 2. The runner's own build gate. The agent built it too, so a failure here is usually this machine's
     // environment — check that before sending the agent after an error that was never its own.
@@ -2024,7 +2063,7 @@ async function produceChangeWithAgent(run) {
             const stillForeign = change.overlapping.filter((f) => !carryOverFiles.includes(f));
             if (!gate.ok || change.changed.length === 0 || stillForeign.length > 0) {
                 await revert(change.changed);
-                return backToHuman(`${engine.label} made the change, but the project did not build with it, and its attempt to fix that did not get the build green. I reverted everything rather than ship a broken build.\n\n\`\`\`\n${buildErrorExcerpt(gate.errorOutput || '')}\n\`\`\`\n\nYour description was clear — nothing more is needed from you on that. Reply here to have it try again.`, `Reverted: the build failed after ${engine.label}'s change`, []);
+                return backToHuman(`${engine.label} made the change, but the project did not build with it, and its attempt to fix that did not get the build green. I reverted everything rather than ship a broken build.\n\n\`\`\`\n${buildErrorExcerpt(gate.errorOutput || '')}\n\`\`\`\n\nYour description was clear — nothing more is needed from you on that. Reply here to have it try again.`, `Reverted: the build failed after ${engine.label}'s change`, [], TRY_AGAIN);
             }
         }
     }
@@ -2497,7 +2536,7 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 const changed = modifiedFiles.map((f) => `\`${f}\``).join(', ');
                 await client.askQuestion(card.id, provider, deployInfo.errorKind === 'needs_confirmation'
                     ? `I made the code change (${changed}). One question before I deploy this project for the first time:\n\n${describeFailureForHuman(deployInfo)}`
-                    : `I made the code change (${changed}), but the deployment could not be verified, so I kept this card in progress instead of moving it to Testing.\n\n${describeFailureForHuman(deployInfo)}`);
+                    : `I made the code change (${changed}), but the deployment could not be verified, so I kept this card in progress instead of moving it to Testing.\n\n${describeFailureForHuman(deployInfo)}`, deployReplyOptions(deployInfo));
                 return false;
             }
             if (deployInfo.pending && deployInfo.pendingVerification) {
@@ -2812,7 +2851,7 @@ async function processPendingVerifications(client, projectPaths) {
                         attempts: 1,
                         last_error: detail,
                     });
-                    await client.askQuestion(p.card_id, p.provider, `The deployment I started for this card did not succeed, so the change is NOT live yet.\n\nWhat failed: ${detail}\n\nFix the failing step and reply **retry**, or tell me the right route with \`deploy: <method or command>\`.`);
+                    await client.askQuestion(p.card_id, p.provider, `The deployment I started for this card did not succeed, so the change is NOT live yet.\n\nWhat failed: ${detail}\n\nFix the failing step and reply **retry**, or tell me the right route with \`deploy: <method or command>\`.`, deployReplyOptions({ errorKind: 'ci_failed' }));
                     await client.reportDeployment({ card_id: p.card_id, project_path: projectPath, method: 'github_actions', ok: false, error: detail.slice(0, 480), error_kind: 'ci_failed', commit: short });
                 }
                 else if (ageMs > 90 * 60 * 1000) {
@@ -2879,6 +2918,7 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
     let holdsWorkerLock = false;
     let journalsRecovered = false;
     let consecutiveFailures = 0;
+    let warnedNoKey = false;
     const autoProvisionSavedBindings = (apiKey, bindings) => {
         for (const b of bindings) {
             const projPath = (b.project_path || '').trim();
@@ -2957,19 +2997,28 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
         try {
             const config = client.loadProjectConfig();
             const apiKey = client.getApiKey();
-            if (!config?.board_id || !apiKey) {
+            // The background service is not started inside a project folder: it has no board of its own and
+            // serves every folder linked on this machine. A coding tool's MCP server only pulses for its project.
+            const homeBoardId = config?.board_id || '';
+            if (!apiKey || (!homeBoardId && role !== 'daemon')) {
+                if (role === 'daemon' && !apiKey && !warnedNoKey) {
+                    warnedNoKey = true;
+                    log.warn('daemon.no_api_key', { hint: 'run `npx -y @agilemonster/mcp-server bootstrap` in a project folder' });
+                }
                 return;
             }
+            const homePath = homeBoardId ? config?.project_path || process.cwd() : '';
             const includeDiscovery = pulseCount === 0 || pulseCount % 3 === 0;
             pulseCount++;
             const res = await client.pulse({
-                boardId: config.board_id,
+                boardId: homeBoardId || undefined,
                 provider: 'any',
-                projectName: config.project_name || path.basename(process.cwd()),
-                projectPath: config.project_path || process.cwd(),
+                projectName: homeBoardId ? config?.project_name || path.basename(process.cwd()) : undefined,
+                projectPath: homePath || undefined,
                 discoveredProjects: includeDiscovery ? client.discoverLocalProjects() : undefined,
                 discoveredModels: includeDiscovery ? client.discoverLocalAgentModels() : undefined,
                 activeClaims: activeClaims(),
+                machine: await machineReport(role).catch(() => undefined),
             });
             if (consecutiveFailures > 0) {
                 log.info('pulse.recovered', { after_failures: consecutiveFailures });
@@ -2979,13 +3028,14 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
                 autoProvisionSavedBindings(apiKey, res.saved_bindings);
             }
             const queued = res.queued_cards || [];
-            syncIdeTaskRules(config.board_name || 'Board', queued);
+            if (homeBoardId)
+                syncIdeTaskRules(config?.board_name || 'Board', queued);
             for (const card of queued) {
                 if (!notifiedCardIds.has(card.id)) {
                     notifiedCardIds.add(card.id);
                     const worker = card.agent_display_name || card.agent_provider || 'AI Agent';
                     const modelTag = card.agent_model && card.agent_model !== 'auto' ? ` [${card.agent_model}]` : '';
-                    sendDesktopNotification(`Agile Monster -> ${worker}${modelTag}`, `New task queued on ${config.board_name || 'Board'}: "${card.title}"`);
+                    sendDesktopNotification(`Agile Monster -> ${worker}${modelTag}`, `New task queued on ${config?.board_name || 'Board'}: "${card.title}"`);
                     try {
                         if (server) {
                             await server.sendResourceUpdated({ uri: 'agilemonster://project/context' });
@@ -3005,7 +3055,7 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
                 const boundQueued = res.all_bound_queued_cards || [];
                 for (const qCard of boundQueued) {
                     const targetPath = (qCard.bound_project_path || '').trim() ||
-                        (qCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                        (homeBoardId && qCard.board_id === homeBoardId ? homePath : '');
                     if (targetPath && fs.existsSync(targetPath)) {
                         await executeQueuedCardAutonomously(client, qCard, targetPath);
                     }
@@ -3016,12 +3066,12 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
                 const boundDone = res.all_bound_done_cards || [];
                 for (const dCard of boundDone) {
                     const targetPath = (dCard.bound_project_path || '').trim() ||
-                        (dCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                        (homeBoardId && dCard.board_id === homeBoardId ? homePath : '');
                     if (targetPath && fs.existsSync(targetPath)) {
                         await deployApprovedCardIfNeeded(client, dCard, targetPath);
                     }
                 }
-                const knownPaths = new Set([config.project_path || process.cwd()]);
+                const knownPaths = new Set(homePath ? [homePath] : []);
                 for (const b of res.saved_bindings || []) {
                     if (b.project_path)
                         knownPaths.add(b.project_path.trim());
@@ -3079,6 +3129,10 @@ export async function runBackgroundPulseDaemon(intervalMs = 20000) {
         log.error('daemon.uncaught_exception', { error: errorMessage(err), stack: err instanceof Error ? err.stack : undefined });
         process.exit(1);
     });
+    // Which agent will work a queued card here, on record before the first card arrives
+    engineStatuses()
+        .then((agents) => log.info('daemon.agents', { agents: agents.map((a) => ({ id: a.id, ready: !a.problem, bin: a.bin, problem: a.problem })) }))
+        .catch(() => { });
     startBuiltInPullPulse(null, client, intervalMs, 'daemon');
     // Watch dist/server.js for updates so launchd reloads new code after a rebuild — but only between jobs,
     // never in the middle of an edit or a deployment.

package/dist/service.d.ts

@@ -0,0 +1,82 @@
+import { ExecOptions, ExecResult } from './runtime.js';
+/**
+ * Runs the card runner as a background service that starts with the computer.
+ *
+ * Without this, cards queued from the board are only worked while an AI coding tool happens to be open in
+ * the project folder (its MCP server pulses as a side effect). People do not know that, so their first card
+ * sits in "queued" for ever. `bootstrap` installs the service; `service install|status|uninstall` manage it.
+ *
+ * The service runs its own copy of the package from ~/.agilemonster/runner, so it does not depend on an npx
+ * cache that can be cleared or on a project folder that can move, and it updates that copy itself.
+ *
+ * macOS: a launchd agent. Linux: a systemd user unit. Windows: not yet.
+ */
+export declare const SERVICE_LABEL = "com.agilemonster.pulse";
+export declare const SYSTEMD_UNIT = "agilemonster-runner.service";
+export type ServiceKind = 'launchd' | 'systemd';
+export interface ServiceDeps {
+    platform: NodeJS.Platform;
+    home: string;
+    /** Machine-local Agile Monster folder (~/.agilemonster). */
+    amHome: string;
+    uid: number | null;
+    node: string;
+    npm: string | null;
+    pathEnv: string;
+    exec: (command: string, args?: string[], options?: ExecOptions) => Promise<ExecResult>;
+}
+/**
+ * The node binary the service should start. `process.execPath` is often a versioned folder (Homebrew's
+ * Cellar/node@24/24.21.0_1/…) that disappears with the next upgrade and would leave the service unable to
+ * start; the `node` on PATH is a stable link to the same binary, so prefer it when it is the same one.
+ */
+export declare function stableNodePath(): string;
+export declare function defaultServiceDeps(): ServiceDeps;
+export declare function runnerDir(amHome: string): string;
+/** The service's own copy of this package's entry point. */
+export declare function runnerEntry(amHome: string): string;
+export declare function serviceKind(platform: NodeJS.Platform): ServiceKind | null;
+export declare function unitPath(kind: ServiceKind, home: string): string;
+export interface UnitOptions {
+    node: string;
+    entry: string;
+    home: string;
+    logDir: string;
+    pathEnv: string;
+}
+export declare function launchdPlist(o: UnitOptions): string;
+export declare function systemdUnit(o: UnitOptions): string;
+/** The program an existing unit file starts (the script after the node binary), or null when unreadable. */
+export declare function unitTarget(kind: ServiceKind, content: string): string | null;
+export interface ServiceStatus {
+    supported: boolean;
+    kind: ServiceKind | null;
+    unitPath: string | null;
+    installed: boolean;
+    /** True when the unit starts the copy this module installs (not a hand-made or development setup). */
+    managed: boolean;
+    target: string | null;
+    running: boolean;
+}
+export declare function serviceStatus(deps?: ServiceDeps): Promise<ServiceStatus>;
+export interface ServiceResult {
+    ok: boolean;
+    /** 'installed' | 'kept' (someone else's setup left alone) | 'unsupported' | 'failed' | 'removed' | 'absent' */
+    outcome: 'installed' | 'kept' | 'unsupported' | 'failed' | 'removed' | 'absent';
+    message: string;
+}
+export declare function installService(options: {
+    force?: boolean;
+    hasApiKey: boolean;
+}, deps?: ServiceDeps): Promise<ServiceResult>;
+export declare function uninstallService(options?: {
+    force?: boolean;
+}, deps?: ServiceDeps): Promise<ServiceResult>;
+/** npm arguments that install or update the service's own copy of the package. */
+export declare function updateArgs(dir: string, version?: string): string[];
+/**
+ * When this process is the service's own copy, the folder to update in place. Null for a copy started by
+ * npx, a global install or a source checkout: those update the way they were installed.
+ */
+export declare function managedRunnerDir(runningFile: string, amHome?: string): string | null;
+export declare function describeService(deps?: ServiceDeps): Promise<string>;