@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/update/updateStatus.js

@@ -0,0 +1,703 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, realpath, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const TASKFORCE_PACKAGE = '@taskforcehq/taskforce';
+const DEFAULT_TIMEOUT_MS = 3_000;
+const DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_NPM_LATEST_URL = 'https://registry.npmjs.org/@taskforcehq%2Ftaskforce/latest';
+const DEFAULT_HOMEBREW_FORMULA_URL = 'https://raw.githubusercontent.com/taskforcehq/homebrew-tap/HEAD/Formula/taskforce.rb';
+export class TaskforceUpdateSourceError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'TaskforceUpdateSourceError';
+    }
+}
+function parseVersion(value) {
+    const raw = String(value || '').trim().replace(/^v/i, '');
+    const match = raw.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match)
+        return null;
+    return {
+        raw: `${match[1]}.${match[2]}.${match[3]}${match[4] ? `-${match[4]}` : ''}`,
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4]
+            ? match[4].split('.').map((part) => /^\d+$/.test(part) ? Number(part) : part)
+            : [],
+    };
+}
+export function compareTaskforceVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return null;
+    for (const key of ['major', 'minor', 'patch']) {
+        if (a[key] !== b[key])
+            return a[key] > b[key] ? 1 : -1;
+    }
+    if (a.prerelease.length === 0 && b.prerelease.length === 0)
+        return 0;
+    if (a.prerelease.length === 0)
+        return 1;
+    if (b.prerelease.length === 0)
+        return -1;
+    const length = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const aPart = a.prerelease[index];
+        const bPart = b.prerelease[index];
+        if (aPart === undefined)
+            return -1;
+        if (bPart === undefined)
+            return 1;
+        if (aPart === bPart)
+            continue;
+        if (typeof aPart === 'number' && typeof bPart === 'number')
+            return aPart > bPart ? 1 : -1;
+        if (typeof aPart === 'number')
+            return -1;
+        if (typeof bPart === 'number')
+            return 1;
+        return aPart > bPart ? 1 : -1;
+    }
+    return 0;
+}
+function normalizedStableVersion(value) {
+    const parsed = parseVersion(value);
+    if (!parsed || parsed.prerelease.length > 0)
+        return null;
+    return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+}
+async function resolveExecutableOnPath(command, env, pathExists) {
+    const pathValue = String(env.PATH || '').trim();
+    if (!pathValue)
+        return null;
+    const extensions = process.platform === 'win32'
+        ? String(env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+        : [''];
+    for (const directory of pathValue.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = path.join(directory, `${command}${extension}`);
+            if (await pathExists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function isPathInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function defaultRun(command, args, timeoutMs, env) {
+    let launchCommand = command;
+    let launchArgs = args;
+    if (process.platform === 'win32' && /\.cmd$/i.test(command) && /^npm\.cmd$/i.test(path.basename(command))) {
+        const npmCliPath = path.join(path.dirname(command), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+        await access(npmCliPath);
+        launchCommand = process.execPath;
+        launchArgs = [npmCliPath, ...args];
+    }
+    const { stdout } = await execFileAsync(launchCommand, launchArgs, {
+        timeout: timeoutMs,
+        maxBuffer: 64 * 1024,
+        windowsHide: true,
+        env: {
+            ...env,
+            HOMEBREW_NO_AUTO_UPDATE: '1',
+        },
+    });
+    return String(stdout || '').trim();
+}
+async function defaultFetchText(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        let response;
+        try {
+            response = await fetch(url, {
+                signal: controller.signal,
+                headers: { accept: 'application/json, text/plain;q=0.9' },
+            });
+        }
+        catch {
+            throw new TaskforceUpdateSourceError('offline', 'The update source could not be reached');
+        }
+        if (!response.ok) {
+            throw new TaskforceUpdateSourceError('http-error', `Update source returned ${response.status}`);
+        }
+        const payload = await response.text();
+        if (payload.length > 64 * 1024) {
+            throw new TaskforceUpdateSourceError('invalid-response', 'Update source payload exceeded the allowed size');
+        }
+        return payload;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function verifiedRealPath(candidate, resolvePath, pathExists) {
+    const value = String(candidate || '').trim();
+    if (!value)
+        return null;
+    if (!await pathExists(value))
+        return null;
+    try {
+        const resolved = path.resolve(await resolvePath(value));
+        return await pathExists(resolved) ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultPathExists(candidate) {
+    try {
+        await access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultReadPackageName(packageRoot) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+        return String(parsed?.name || '').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function detectChannel(input, dependencies) {
+    if (input.runtimeMode === 'cloud') {
+        return {
+            channel: 'cloud',
+            evidence: ['runtime:cloud'],
+            identityPath: null,
+            managerExecutable: null,
+            homebrewFormula: null,
+        };
+    }
+    const packageRoot = await verifiedRealPath(input.packageRoot, dependencies.resolveRealPath, dependencies.pathExists);
+    const executablePath = await verifiedRealPath(input.executablePath, dependencies.resolveRealPath, dependencies.pathExists);
+    const candidates = [packageRoot, executablePath].filter((value) => Boolean(value));
+    const evidence = [];
+    let npmIdentityPath = null;
+    let brewIdentityPath = null;
+    let matchedFormula = null;
+    const npmExecutable = await resolveExecutableOnPath('npm', dependencies.env, dependencies.pathExists);
+    if (npmExecutable) {
+        try {
+            const npmRootRaw = await dependencies.run(npmExecutable, ['root', '--global'], dependencies.timeoutMs);
+            const npmRoot = await verifiedRealPath(npmRootRaw, dependencies.resolveRealPath, dependencies.pathExists);
+            const npmPackageRoot = npmRoot
+                ? await verifiedRealPath(path.join(npmRoot, '@taskforcehq', 'taskforce'), dependencies.resolveRealPath, dependencies.pathExists)
+                : null;
+            if (npmPackageRoot && candidates.some((candidate) => isPathInside(npmPackageRoot, candidate))) {
+                npmIdentityPath = npmPackageRoot;
+                evidence.push('npm:global-package-root');
+            }
+        }
+        catch {
+            // Missing or unusable npm evidence must not classify the installation.
+        }
+    }
+    const brewExecutable = await resolveExecutableOnPath('brew', dependencies.env, dependencies.pathExists);
+    if (brewExecutable) {
+        for (const formula of ['taskforcehq/tap/taskforce', 'taskforce']) {
+            try {
+                const brewPrefixRaw = await dependencies.run(brewExecutable, ['--prefix', formula], dependencies.timeoutMs);
+                const brewPrefix = await verifiedRealPath(brewPrefixRaw, dependencies.resolveRealPath, dependencies.pathExists);
+                if (brewPrefix && candidates.some((candidate) => isPathInside(brewPrefix, candidate))) {
+                    brewIdentityPath = brewPrefix;
+                    matchedFormula = formula;
+                    evidence.push(`homebrew:formula-prefix:${formula}`);
+                    break;
+                }
+            }
+            catch {
+                // Try the next supported formula name.
+            }
+        }
+    }
+    if (npmIdentityPath && brewIdentityPath) {
+        return {
+            channel: 'conflicting',
+            evidence,
+            identityPath: null,
+            managerExecutable: null,
+            homebrewFormula: null,
+        };
+    }
+    if (npmIdentityPath) {
+        return {
+            channel: 'npm-global',
+            evidence,
+            identityPath: npmIdentityPath,
+            managerExecutable: npmExecutable,
+            homebrewFormula: null,
+        };
+    }
+    if (brewIdentityPath) {
+        return {
+            channel: 'homebrew',
+            evidence,
+            identityPath: brewIdentityPath,
+            managerExecutable: brewExecutable,
+            homebrewFormula: matchedFormula,
+        };
+    }
+    const packageName = packageRoot ? await dependencies.readPackageName(packageRoot) : null;
+    if (packageRoot
+        && packageName === TASKFORCE_PACKAGE
+        && await dependencies.pathExists(path.join(packageRoot, '.git'))) {
+        return {
+            channel: 'development',
+            evidence: ['filesystem:git-checkout', 'package:taskforce'],
+            identityPath: packageRoot,
+            managerExecutable: null,
+            homebrewFormula: null,
+        };
+    }
+    if (packageName === TASKFORCE_PACKAGE
+        && candidates.some((candidate) => candidate.includes(`${path.sep}_npx${path.sep}`)
+            || candidate.includes(`${path.sep}node_modules${path.sep}`))) {
+        return {
+            channel: 'npx-project-local',
+            evidence: ['filesystem:non-global-node-package', 'package:taskforce'],
+            identityPath: packageRoot || executablePath,
+            managerExecutable: null,
+            homebrewFormula: null,
+        };
+    }
+    return {
+        channel: 'unknown',
+        evidence: [],
+        identityPath: packageRoot || executablePath,
+        managerExecutable: null,
+        homebrewFormula: null,
+    };
+}
+function buildInstallationId(channel, identityPath) {
+    if (channel === 'cloud')
+        return 'cloud';
+    if (!identityPath || channel === 'conflicting')
+        return null;
+    return createHash('sha256')
+        .update(`${channel}\0${path.resolve(identityPath)}`)
+        .digest('hex')
+        .slice(0, 20);
+}
+function updateCommands(channel, version, managerExecutable, homebrewFormula) {
+    if (channel === 'npm-global' && managerExecutable) {
+        const args = ['install', '--global', `${TASKFORCE_PACKAGE}@${version}`];
+        return [{
+                manager: 'npm',
+                executable: managerExecutable,
+                args,
+                display: `npm ${args.join(' ')}`,
+                verified: true,
+            }];
+    }
+    if (channel === 'homebrew' && managerExecutable && homebrewFormula) {
+        return [
+            {
+                manager: 'brew',
+                executable: managerExecutable,
+                args: ['update'],
+                display: 'brew update',
+                verified: true,
+            },
+            {
+                manager: 'brew',
+                executable: managerExecutable,
+                args: ['upgrade', homebrewFormula],
+                display: `brew upgrade ${homebrewFormula}`,
+                verified: true,
+            },
+        ];
+    }
+    return [];
+}
+function unknownFallbackCommands() {
+    return [
+        {
+            manager: 'npm',
+            executable: 'npm',
+            args: ['install', '--global', TASKFORCE_PACKAGE],
+            display: `npm install --global ${TASKFORCE_PACKAGE}`,
+            verified: false,
+        },
+        {
+            manager: 'brew',
+            executable: 'brew',
+            args: ['update'],
+            display: 'brew update',
+            verified: false,
+        },
+        {
+            manager: 'brew',
+            executable: 'brew',
+            args: ['upgrade', 'taskforce'],
+            display: 'brew upgrade taskforce',
+            verified: false,
+        },
+    ];
+}
+function verifiedFallbackCommands(channel, managerExecutable, homebrewFormula) {
+    if (channel === 'npm-global') {
+        const args = ['install', '--global', TASKFORCE_PACKAGE];
+        return [{
+                manager: 'npm',
+                executable: managerExecutable,
+                args,
+                display: `npm ${args.join(' ')}`,
+                verified: true,
+            }];
+    }
+    if (!homebrewFormula)
+        return [];
+    return [
+        {
+            manager: 'brew',
+            executable: managerExecutable,
+            args: ['update'],
+            display: 'brew update',
+            verified: true,
+        },
+        {
+            manager: 'brew',
+            executable: managerExecutable,
+            args: ['upgrade', homebrewFormula],
+            display: `brew upgrade ${homebrewFormula}`,
+            verified: true,
+        },
+    ];
+}
+function parseNpmLatest(payload) {
+    try {
+        return normalizedStableVersion(String(JSON.parse(payload)?.version || ''));
+    }
+    catch {
+        return null;
+    }
+}
+function parseHomebrewFormulaVersion(payload) {
+    const match = payload.match(/^\s*url\s+["'][^"']*taskforce-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\.tgz["']/m);
+    return match ? normalizedStableVersion(match[1]) : null;
+}
+async function resolveLatestRelease(channel, dependencies) {
+    const nowMs = dependencies.now().getTime();
+    const cached = await dependencies.cache.read(channel).catch(() => null);
+    const cachedAt = cached ? Date.parse(cached.checkedAt) : Number.NaN;
+    const cachedVersion = cached ? normalizedStableVersion(cached.version) : null;
+    const cacheAgeMs = nowMs - cachedAt;
+    if (cachedVersion && Number.isFinite(cachedAt) && cacheAgeMs >= 0 && cacheAgeMs <= dependencies.cacheTtlMs) {
+        return { version: cachedVersion, source: 'fresh-cache', reason: 'none' };
+    }
+    try {
+        const payload = await dependencies.fetchText(channel === 'npm-global' ? dependencies.npmLatestUrl : dependencies.homebrewFormulaUrl, dependencies.timeoutMs);
+        const version = channel === 'npm-global'
+            ? parseNpmLatest(payload)
+            : parseHomebrewFormulaVersion(payload);
+        if (!version) {
+            throw new TaskforceUpdateSourceError('invalid-response', 'Update source did not provide a stable Taskforce version');
+        }
+        await dependencies.cache.write({ channel, version, checkedAt: dependencies.now().toISOString() }).catch(() => undefined);
+        return { version, source: 'network', reason: 'none' };
+    }
+    catch (error) {
+        const failureReason = error instanceof TaskforceUpdateSourceError
+            ? error.reason
+            : 'offline';
+        const reason = failureReason === 'http-error'
+            ? 'release-http-error'
+            : failureReason === 'invalid-response'
+                ? 'release-invalid'
+                : 'release-offline';
+        if (cachedVersion) {
+            return { version: cachedVersion, source: 'stale-cache', reason };
+        }
+        return { version: null, source: 'none', reason };
+    }
+}
+function buildGuidance(channel, state, target, reason) {
+    if (reason === 'global-cli-not-found')
+        return 'No Global Taskforce CLI was found on PATH.';
+    if (reason === 'global-cli-version-invalid')
+        return 'The Global Taskforce CLI did not return a valid version.';
+    if (reason === 'release-offline')
+        return 'Update availability could not be refreshed while offline; cached information may be shown.';
+    if (reason === 'release-http-error')
+        return 'The release source returned an error, so update availability could not be confirmed.';
+    if (reason === 'release-invalid')
+        return 'The release source returned invalid version information.';
+    if (reason === 'installed-version-invalid')
+        return 'The installed Taskforce version could not be interpreted safely.';
+    if (channel === 'cloud')
+        return 'Cloud deployments are updated by the deployment pipeline.';
+    if (channel === 'development')
+        return 'Development checkouts are updated through source control, not the package updater.';
+    if (channel === 'npx-project-local')
+        return 'This installation is managed by npx or the project package manager.';
+    if (channel === 'conflicting')
+        return 'Multiple package managers appear to own this installation. Update it manually after resolving the conflict.';
+    if (channel === 'unknown')
+        return 'The installation owner could not be verified. Use manual npm or Homebrew guidance.';
+    if (state === 'available')
+        return `${target === 'app' ? 'Taskforce' : 'The Global MCP CLI'} can be updated through the verified ${channel === 'npm-global' ? 'npm' : 'Homebrew'} installation.`;
+    if (state === 'ahead')
+        return 'The installed version is newer than the latest stable release for this channel; no downgrade is recommended.';
+    if (state === 'current')
+        return 'This installation is current for its verified release channel.';
+    return 'Update availability could not be confirmed. The installed version remains usable.';
+}
+function unsupportedReason(channel) {
+    if (channel === 'cloud')
+        return 'cloud-managed';
+    if (channel === 'development')
+        return 'development-install';
+    if (channel === 'npx-project-local')
+        return 'project-managed';
+    if (channel === 'conflicting')
+        return 'ownership-conflict';
+    return 'ownership-unknown';
+}
+async function inspectInstallation(input, dependencies) {
+    const checkedAt = dependencies.now().toISOString();
+    const installed = parseVersion(input.version)?.raw || null;
+    const detected = await detectChannel(input, dependencies);
+    const verifiedChannel = detected.channel === 'npm-global' || detected.channel === 'homebrew'
+        ? detected.channel
+        : null;
+    const latest = verifiedChannel
+        ? await resolveLatestRelease(verifiedChannel, dependencies)
+        : {
+            version: null,
+            source: 'none',
+            reason: 'none',
+        };
+    let state = 'unsupported';
+    let reason = unsupportedReason(detected.channel);
+    if (verifiedChannel) {
+        const comparison = installed && latest.version
+            ? compareTaskforceVersions(installed, latest.version)
+            : null;
+        state = comparison === null
+            ? 'indeterminate'
+            : comparison < 0
+                ? 'available'
+                : comparison > 0
+                    ? 'ahead'
+                    : latest.source === 'stale-cache'
+                        ? 'indeterminate'
+                        : 'current';
+        reason = !installed
+            ? 'installed-version-invalid'
+            : latest.reason;
+    }
+    const verifiedCommands = latest.version && (state === 'available' || !installed)
+        ? updateCommands(detected.channel, latest.version, detected.managerExecutable, detected.homebrewFormula)
+        : [];
+    const verifiedFallback = verifiedChannel
+        && detected.managerExecutable
+        && state === 'indeterminate'
+        ? verifiedFallbackCommands(verifiedChannel, detected.managerExecutable, detected.homebrewFormula)
+        : [];
+    const commands = detected.channel === 'unknown' || detected.channel === 'conflicting'
+        ? unknownFallbackCommands()
+        : verifiedCommands.length > 0
+            ? verifiedCommands
+            : verifiedFallback;
+    return {
+        target: input.target,
+        channel: detected.channel,
+        installationId: buildInstallationId(detected.channel, detected.identityPath),
+        installedVersion: installed,
+        latestVersion: latest.version,
+        state,
+        reason,
+        releaseSource: latest.source,
+        checkedAt,
+        evidence: detected.evidence,
+        updateCommands: commands,
+        canAutoUpdate: state === 'available'
+            && Boolean(verifiedChannel)
+            && latest.source !== 'stale-cache'
+            && verifiedCommands.length > 0,
+        requiresRestart: state === 'available',
+        restartTarget: state === 'available'
+            ? input.target === 'app' ? 'taskforce' : 'mcp-clients'
+            : null,
+        guidance: buildGuidance(detected.channel, state, input.target, reason),
+    };
+}
+function normalizeCliVersionOutput(value) {
+    const normalized = String(value || '')
+        .replace(/\u001b\[[0-9;]*m/g, '')
+        .trim();
+    const match = normalized.match(/^(?:Taskforce CLI v)?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+[0-9A-Za-z.-]+)?$/);
+    return match?.[1] || null;
+}
+export function deriveTaskforcePackageRootFromCliEntry(cliEntry, platform = process.platform) {
+    const pathApi = platform === 'win32' ? path.win32 : path;
+    const normalized = String(cliEntry || '').trim();
+    if (pathApi.basename(normalized).toLowerCase() !== 'cli.js')
+        return null;
+    const distDirectory = pathApi.dirname(normalized);
+    if (pathApi.basename(distDirectory).toLowerCase() !== 'dist')
+        return null;
+    return pathApi.dirname(distDirectory);
+}
+async function discoverGlobalCli(runtimeMode, dependencies) {
+    if (runtimeMode === 'cloud')
+        return { input: null, failureReason: null };
+    const executable = await resolveExecutableOnPath('taskforce', dependencies.env, dependencies.pathExists);
+    const executablePath = await verifiedRealPath(executable, dependencies.resolveRealPath, dependencies.pathExists);
+    if (!executablePath) {
+        return { input: null, failureReason: 'global-cli-not-found' };
+    }
+    let launchCommand = executablePath;
+    let launchArgs = ['--version'];
+    let packageRoot = deriveTaskforcePackageRootFromCliEntry(executablePath);
+    if (process.platform === 'win32' && /\.(?:cmd|bat)$/i.test(executablePath)) {
+        const cliEntry = path.win32.join(path.win32.dirname(executablePath), 'node_modules', '@taskforcehq', 'taskforce', 'dist', 'cli.js');
+        if (!await dependencies.pathExists(cliEntry)) {
+            return {
+                input: {
+                    target: 'global-cli',
+                    version: '',
+                    runtimeMode,
+                    executablePath,
+                },
+                failureReason: 'global-cli-version-invalid',
+            };
+        }
+        launchCommand = process.execPath;
+        launchArgs = [cliEntry, '--version'];
+        packageRoot = deriveTaskforcePackageRootFromCliEntry(cliEntry, 'win32');
+    }
+    try {
+        const version = normalizeCliVersionOutput(await dependencies.run(launchCommand, launchArgs, dependencies.timeoutMs));
+        return {
+            input: {
+                target: 'global-cli',
+                version: version || '',
+                runtimeMode,
+                executablePath,
+                packageRoot,
+            },
+            failureReason: version ? null : 'global-cli-version-invalid',
+        };
+    }
+    catch {
+        return {
+            input: {
+                target: 'global-cli',
+                version: '',
+                runtimeMode,
+                executablePath,
+                packageRoot,
+            },
+            failureReason: 'global-cli-version-invalid',
+        };
+    }
+}
+function missingGlobalCliStatus(checkedAt, reason) {
+    return {
+        target: 'global-cli',
+        channel: 'unknown',
+        installationId: null,
+        installedVersion: null,
+        latestVersion: null,
+        state: 'unsupported',
+        reason,
+        releaseSource: 'none',
+        checkedAt,
+        evidence: [],
+        updateCommands: unknownFallbackCommands(),
+        canAutoUpdate: false,
+        requiresRestart: false,
+        restartTarget: null,
+        guidance: buildGuidance('unknown', 'unsupported', 'global-cli', reason),
+    };
+}
+export class JsonTaskforceReleaseCache {
+    filePath;
+    constructor(filePath = path.join(os.homedir(), '.taskforce', 'update-status-cache.json')) {
+        this.filePath = filePath;
+    }
+    async readAll() {
+        try {
+            return JSON.parse(await readFile(this.filePath, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    async read(channel) {
+        return (await this.readAll())[channel] || null;
+    }
+    async write(entry) {
+        const entries = await this.readAll();
+        entries[entry.channel] = entry;
+        await mkdir(path.dirname(this.filePath), { recursive: true });
+        const temporaryPath = `${this.filePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+        await writeFile(temporaryPath, `${JSON.stringify(entries, null, 2)}\n`, { mode: 0o600 });
+        await rename(temporaryPath, this.filePath);
+    }
+}
+function buildUpdateStatusDependencies(supplied) {
+    return {
+        now: supplied.now || (() => new Date()),
+        env: supplied.env || process.env,
+        run: supplied.run || ((command, args, timeoutMs) => defaultRun(command, args, timeoutMs, supplied.env || process.env)),
+        fetchText: supplied.fetchText || defaultFetchText,
+        resolveRealPath: supplied.resolveRealPath || realpath,
+        pathExists: supplied.pathExists || defaultPathExists,
+        readPackageName: supplied.readPackageName || defaultReadPackageName,
+        cache: supplied.cache || new JsonTaskforceReleaseCache(),
+        timeoutMs: Math.max(500, Math.min(10_000, supplied.timeoutMs || DEFAULT_TIMEOUT_MS)),
+        cacheTtlMs: Math.max(0, supplied.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS),
+        npmLatestUrl: supplied.npmLatestUrl || DEFAULT_NPM_LATEST_URL,
+        homebrewFormulaUrl: supplied.homebrewFormulaUrl || DEFAULT_HOMEBREW_FORMULA_URL,
+    };
+}
+export async function getTaskforceInstallationStatus(input, supplied = {}) {
+    return inspectInstallation(input, buildUpdateStatusDependencies(supplied));
+}
+export async function getTaskforceUpdateStatus(input, supplied = {}) {
+    const dependencies = buildUpdateStatusDependencies(supplied);
+    // Keep release lookups sequential so app and CLI targets on the same channel
+    // share the just-written cache instead of making duplicate network requests.
+    const app = await inspectInstallation(input.app, dependencies);
+    const discoveredGlobalCli = input.globalCli === undefined
+        ? await discoverGlobalCli(input.app.runtimeMode, dependencies)
+        : { input: input.globalCli, failureReason: null };
+    let globalCli = discoveredGlobalCli.input
+        ? await inspectInstallation(discoveredGlobalCli.input, dependencies)
+        : null;
+    if (discoveredGlobalCli.failureReason) {
+        globalCli = globalCli
+            ? {
+                ...globalCli,
+                reason: discoveredGlobalCli.failureReason,
+                guidance: buildGuidance(globalCli.channel, globalCli.state, 'global-cli', discoveredGlobalCli.failureReason),
+                canAutoUpdate: false,
+            }
+            : missingGlobalCliStatus(dependencies.now().toISOString(), discoveredGlobalCli.failureReason);
+    }
+    return {
+        checkedAt: dependencies.now().toISOString(),
+        app,
+        globalCli,
+        installationsDiffer: Boolean(globalCli && (app.channel !== globalCli.channel
+            || app.installedVersion !== globalCli.installedVersion
+            || app.installationId !== globalCli.installationId)),
+    };
+}