newmark-agent 0.4.5 → 0.4.7

package/dist/core/installUpdate.js

@@ -39,6 +39,15 @@ exports.normalizeReleaseVersion = normalizeReleaseVersion;
 exports.compareSemver = compareSemver;
 exports.checkGitHubUpdate = checkGitHubUpdate;
 exports.applyGitHubUpdate = applyGitHubUpdate;
+exports.listRunningNewmarkProcesses = listRunningNewmarkProcesses;
+exports.stopNewmarkProcesses = stopNewmarkProcesses;
+exports.listInstalledNewmarkProducts = listInstalledNewmarkProducts;
+exports.uninstallNewmarkProduct = uninstallNewmarkProduct;
+exports.installMsiPackage = installMsiPackage;
+exports.findLegacyNewmarkExecutables = findLegacyNewmarkExecutables;
+exports.removeLegacyNewmarkExecutables = removeLegacyNewmarkExecutables;
+exports.planManagedMsiInstall = planManagedMsiInstall;
+exports.executeManagedMsiInstall = executeManagedMsiInstall;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -518,4 +527,263 @@ async function applyGitHubUpdate(options) {
         };
     }
 }
+const NEWMARK_PROCESS_NAMES = ['Newmark Agent.exe', 'Newmark.exe', 'Newmark Console Runtime.exe'];
+const NEWMARK_LEGACY_EXECUTABLES = new Set(['newmark.exe', 'newmark agent.exe']);
+function normalizeWindowsPathForCompare(value) {
+    return path.resolve(String(value)).toLowerCase();
+}
+function isWithinOrEqual(candidate, parent) {
+    const child = normalizeWindowsPathForCompare(candidate);
+    const rootPath = normalizeWindowsPathForCompare(parent);
+    return child === rootPath || child.startsWith(rootPath.endsWith(path.sep) ? rootPath : rootPath + path.sep);
+}
+function runPowerShellJson(script) {
+    const args = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script];
+    const stdout = (0, child_process_1.execFileSync)('powershell.exe', args, { encoding: 'utf-8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    const trimmed = String(stdout || '').replace(/^\uFEFF/, '').trim();
+    if (!trimmed)
+        return [];
+    const parsed = JSON.parse(trimmed);
+    return Array.isArray(parsed) ? parsed.map(item => item) : [parsed];
+}
+function listRunningNewmarkProcesses() {
+    const nameFilter = NEWMARK_PROCESS_NAMES.map(name => `$_.Name -eq '${name.replace(/'/g, "''")}'`).join(' -or ');
+    const rows = runPowerShellJson(`Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object { ${nameFilter} } | Select-Object ProcessId,Name,ExecutablePath | ConvertTo-Json -Compress`);
+    const skipPid = Number(process.env.NEWMARK_SKIP_PROCESS_PID || process.pid);
+    return rows
+        .map(row => ({
+        pid: Number(row.ProcessId || 0),
+        name: String(row.Name || ''),
+        executablePath: String(row.ExecutablePath || ''),
+    }))
+        .filter(proc => proc.pid > 0 && proc.pid !== skipPid);
+}
+function stopNewmarkProcesses(pids) {
+    const ids = Array.from(new Set((pids || []).map(Number).filter(pid => Number.isFinite(pid) && pid > 0)));
+    if (!ids.length)
+        return { stopped: [], errors: [] };
+    const script = `$ids = @(${ids.join(',')}); foreach ($id in $ids) { try { Stop-Process -Id $id -Force -ErrorAction Stop; Write-Output ('stopped:' + $id) } catch { Write-Output ('error:' + $id + ':' + $_.Exception.Message) } }`;
+    const args = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script];
+    const stdout = String((0, child_process_1.execFileSync)('powershell.exe', args, { encoding: 'utf-8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }) || '');
+    const stopped = [];
+    const errors = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const stoppedMatch = trimmed.match(/^stopped:(\d+)$/);
+        const errorMatch = trimmed.match(/^error:(\d+):(.*)$/);
+        if (stoppedMatch)
+            stopped.push(Number(stoppedMatch[1]));
+        else if (errorMatch)
+            errors.push(`PID ${errorMatch[1]}: ${errorMatch[2]}`);
+    }
+    return { stopped, errors };
+}
+function listInstalledNewmarkProducts() {
+    const rows = runPowerShellJson(`$paths = @('HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*','HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*'); Get-ItemProperty $paths -ErrorAction SilentlyContinue | Where-Object { $_.DisplayName -like '*Newmark Agent*' } | Select-Object PSChildName,DisplayName,InstallLocation,UninstallString,QuietUninstallString | ConvertTo-Json -Compress`);
+    return rows
+        .map(row => ({
+        productCode: String(row.PSChildName || ''),
+        displayName: String(row.DisplayName || ''),
+        installLocation: String(row.InstallLocation || ''),
+        uninstallString: String(row.UninstallString || row.QuietUninstallString || ''),
+    }))
+        .filter(product => product.productCode);
+}
+function runMsiExec(args) {
+    const result = (0, child_process_1.spawnSync)('msiexec.exe', args, { encoding: 'utf-8', windowsHide: true });
+    return {
+        exitCode: result.status === null ? -1 : result.status,
+        stdout: String(result.stdout || ''),
+        stderr: String(result.stderr || ''),
+    };
+}
+function windowsCommandQuote(value) {
+    const text = String(value);
+    return /\s/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+}
+function runElevatedMsiExec(args) {
+    const argumentString = args.map(arg => windowsCommandQuote(arg)).join(' ');
+    const script = [
+        `$argumentList = '${argumentString.replace(/'/g, "''")}'`,
+        '$process = Start-Process -FilePath "msiexec.exe" -ArgumentList $argumentList -Verb RunAs -Wait -PassThru',
+        'Write-Output ("EXITCODE:" + $process.ExitCode)',
+    ].join('; ');
+    const result = (0, child_process_1.spawnSync)('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], { encoding: 'utf-8', windowsHide: true });
+    const stdout = String(result.stdout || '');
+    const match = stdout.match(/EXITCODE:(\d+)/);
+    return {
+        exitCode: match ? Number(match[1]) : (result.status === null ? -1 : result.status),
+        stdout,
+        stderr: String(result.stderr || ''),
+    };
+}
+function uninstallNewmarkProduct(productCode, logPath) {
+    const args = ['/x', productCode, '/qn', '/norestart', '/l*v', logPath];
+    let result = runMsiExec(args);
+    if (result.exitCode !== 0 && result.exitCode !== 3010)
+        result = runElevatedMsiExec(args);
+    const ok = result.exitCode === 0 || result.exitCode === 3010;
+    return {
+        ok,
+        exitCode: result.exitCode,
+        logPath,
+        error: ok ? undefined : `msiexec uninstall exited ${result.exitCode}`,
+    };
+}
+function installMsiPackage(msiPath, options = {}) {
+    const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-install-${process.pid}-${Date.now()}.log`);
+    const args = ['/i', path.resolve(msiPath), '/qn', '/norestart', '/l*v', logPath];
+    let result = runMsiExec(args);
+    if (result.exitCode !== 0 && result.exitCode !== 3010 && options.allowElevate !== false)
+        result = runElevatedMsiExec(args);
+    const ok = result.exitCode === 0 || result.exitCode === 3010;
+    return {
+        ok,
+        exitCode: result.exitCode,
+        logPath,
+        error: ok ? undefined : `msiexec install exited ${result.exitCode}`,
+    };
+}
+function findLegacyNewmarkExecutables(excludeRoots = []) {
+    const found = new Map();
+    for (const name of NEWMARK_PROCESS_NAMES) {
+        try {
+            const stdout = String((0, child_process_1.execFileSync)('where.exe', [name], { encoding: 'utf-8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }) || '');
+            for (const line of stdout.split(/\r?\n/)) {
+                const candidate = String(line || '').trim();
+                if (!candidate)
+                    continue;
+                const key = normalizeWindowsPathForCompare(candidate);
+                if (NEWMARK_LEGACY_EXECUTABLES.has(path.basename(candidate).toLowerCase()) && !found.has(key))
+                    found.set(key, candidate);
+            }
+        }
+        catch {
+            // where.exe returns non-zero when an executable is not found on PATH.
+        }
+    }
+    const exclude = (excludeRoots || []).filter(Boolean).map(root => normalizeWindowsPathForCompare(root));
+    return Array.from(found.values())
+        .filter(candidate => !exclude.some(root => isWithinOrEqual(candidate, root)))
+        .sort();
+}
+function removeLegacyNewmarkExecutables(paths) {
+    const removed = [];
+    const errors = [];
+    for (const candidate of Array.from(new Set(paths || []))) {
+        const full = path.resolve(candidate);
+        if (!NEWMARK_LEGACY_EXECUTABLES.has(path.basename(full).toLowerCase())) {
+            errors.push(`refusing non-Newmark executable: ${full}`);
+            continue;
+        }
+        try {
+            fs.unlinkSync(full);
+            removed.push(full);
+        }
+        catch (e) {
+            errors.push(`${full}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { removed, errors };
+}
+function planManagedMsiInstall(msiPath, options = {}) {
+    const fullPath = path.resolve(msiPath);
+    try {
+        if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile() || path.extname(fullPath).toLowerCase() !== '.msi') {
+            return {
+                ok: false,
+                msiPath: fullPath,
+                runningProcesses: [],
+                installedProducts: [],
+                legacyExecutables: [],
+                needsStopConfirmation: false,
+                needsLegacyRemovalConfirmation: false,
+                error: `MSI package does not exist or is not a .msi file: ${fullPath}`,
+            };
+        }
+        const runningProcesses = listRunningNewmarkProcesses();
+        const installedProducts = listInstalledNewmarkProducts();
+        const excludeRoots = [
+            ...(options.excludeRoots || []),
+            process.cwd(),
+            path.dirname(process.execPath || ''),
+            path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Newmark Agent'),
+            path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'Newmark Agent'),
+            ...installedProducts.map(product => product.installLocation),
+        ];
+        const legacyExecutables = findLegacyNewmarkExecutables(excludeRoots);
+        return {
+            ok: true,
+            msiPath: fullPath,
+            runningProcesses,
+            installedProducts,
+            legacyExecutables,
+            needsStopConfirmation: runningProcesses.length > 0 && options.stopConfirmed !== true,
+            needsLegacyRemovalConfirmation: legacyExecutables.length > 0 && options.removeLegacyConfirmed !== true,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            msiPath: fullPath,
+            runningProcesses: [],
+            installedProducts: [],
+            legacyExecutables: [],
+            needsStopConfirmation: false,
+            needsLegacyRemovalConfirmation: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+function executeManagedMsiInstall(msiPath, options = {}) {
+    const plan = planManagedMsiInstall(msiPath, options);
+    if (!plan.ok) {
+        return { ok: false, plan, stopped: [], uninstalled: [], removedLegacy: [], error: plan.error };
+    }
+    if (plan.needsStopConfirmation) {
+        return { ok: false, plan, stopped: [], uninstalled: [], removedLegacy: [], error: 'Running Newmark processes require confirmation before they can be stopped.' };
+    }
+    if (plan.needsLegacyRemovalConfirmation) {
+        return { ok: false, plan, stopped: [], uninstalled: [], removedLegacy: [], error: 'Legacy Newmark executables require confirmation before they can be removed.' };
+    }
+    const stopResult = plan.runningProcesses.length
+        ? stopNewmarkProcesses(plan.runningProcesses.map(process => process.pid))
+        : { stopped: [], errors: [] };
+    const uninstalled = [];
+    if (options.uninstallPrevious !== false) {
+        for (const product of plan.installedProducts) {
+            const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-uninstall-${product.productCode}-${process.pid}-${Date.now()}.log`);
+            const uninstallResult = uninstallNewmarkProduct(product.productCode, logPath);
+            if (!uninstallResult.ok) {
+                return {
+                    ok: false,
+                    plan,
+                    stopped: stopResult.stopped,
+                    uninstalled,
+                    removedLegacy: [],
+                    exitCode: uninstallResult.exitCode,
+                    logPath: uninstallResult.logPath,
+                    error: `Failed to uninstall previous Newmark version ${product.productCode}: ${uninstallResult.error}`,
+                };
+            }
+            uninstalled.push(product.productCode);
+        }
+    }
+    const removeResult = plan.legacyExecutables.length
+        ? removeLegacyNewmarkExecutables(plan.legacyExecutables)
+        : { removed: [], errors: [] };
+    const installResult = installMsiPackage(plan.msiPath, { logDir: options.logDir, allowElevate: options.allowElevate });
+    return {
+        ok: installResult.ok,
+        plan,
+        stopped: stopResult.stopped,
+        uninstalled,
+        removedLegacy: removeResult.removed,
+        exitCode: installResult.exitCode,
+        logPath: installResult.logPath,
+        error: installResult.error,
+    };
+}
 //# sourceMappingURL=installUpdate.js.map

package/dist/core/mobilePairing.d.ts

@@ -0,0 +1,47 @@
+export declare const MOBILE_TOKEN_FILENAME = ".newmark-mobile-token";
+export declare const MOBILE_PAIRING_FILENAME = ".newmark-mobile-pairing.json";
+export declare const MOBILE_PORT = 47890;
+export declare const MOBILE_PAIRING_TTL_MS = 120000;
+export interface PairingSession {
+    pairingId: string;
+    token: string;
+    host: string;
+    hostname: string;
+    port: number;
+    issuedAt: number;
+    expiresAt: number;
+    url: string;
+    confirmed?: boolean;
+    confirmedAt?: number;
+}
+export interface PairingStatus {
+    pairingId: string;
+    issuedAt: number;
+    expiresAt: number;
+    confirmed: boolean;
+    confirmedAt: number;
+    active: boolean;
+    expired: boolean;
+}
+export declare function ensureMobileToken(root: string): string;
+export declare function tailscaleIpv4(): string | null;
+export declare function lanIpv4(): string | null;
+export declare function pairingHost(): string;
+export declare function createPairingSession(root: string, ttlMs?: number): PairingSession;
+export declare function pairingUrl(root: string): string;
+export declare function pairingTokenPath(root: string): string;
+export declare function pairingStatus(root: string): PairingStatus;
+export declare function confirmPairing(root: string, pairingId: string, token: string): {
+    ok: boolean;
+    error?: string;
+    status: PairingStatus;
+};
+export declare function pairingQrDataUrl(root: string, ttlMs?: number): Promise<{
+    dataUrl: string;
+    session: PairingSession;
+}>;
+export declare function pairingQrAscii(root: string, ttlMs?: number): Promise<{
+    ascii: string;
+    session: PairingSession;
+}>;
+//# sourceMappingURL=mobilePairing.d.ts.map

package/dist/core/mobilePairing.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_PAIRING_TTL_MS = exports.MOBILE_PORT = exports.MOBILE_PAIRING_FILENAME = exports.MOBILE_TOKEN_FILENAME = void 0;
+exports.ensureMobileToken = ensureMobileToken;
+exports.tailscaleIpv4 = tailscaleIpv4;
+exports.lanIpv4 = lanIpv4;
+exports.pairingHost = pairingHost;
+exports.createPairingSession = createPairingSession;
+exports.pairingUrl = pairingUrl;
+exports.pairingTokenPath = pairingTokenPath;
+exports.pairingStatus = pairingStatus;
+exports.confirmPairing = confirmPairing;
+exports.pairingQrDataUrl = pairingQrDataUrl;
+exports.pairingQrAscii = pairingQrAscii;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const QRCode = __importStar(require("qrcode"));
+exports.MOBILE_TOKEN_FILENAME = '.newmark-mobile-token';
+exports.MOBILE_PAIRING_FILENAME = '.newmark-mobile-pairing.json';
+exports.MOBILE_PORT = 47890;
+exports.MOBILE_PAIRING_TTL_MS = 120_000;
+function pairingStatePath(root) {
+    return path.join(root, exports.MOBILE_PAIRING_FILENAME);
+}
+function readPairingState(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pairingStatePath(root), 'utf-8'));
+        if (!parsed || !parsed.pairingId || !parsed.token)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writePairingState(root, state) {
+    fs.mkdirSync(root, { recursive: true });
+    fs.writeFileSync(pairingStatePath(root), JSON.stringify(state, null, 2), 'utf-8');
+}
+function ensureMobileToken(root) {
+    const tokenPath = path.join(root, exports.MOBILE_TOKEN_FILENAME);
+    try {
+        const existing = fs.readFileSync(tokenPath, 'utf-8').replace(/\s+/g, '').trim();
+        if (existing.length >= 32)
+            return existing;
+    }
+    catch {
+        // first start: no token file yet
+    }
+    const generated = (0, crypto_1.randomBytes)(24).toString('hex');
+    try {
+        fs.mkdirSync(root, { recursive: true });
+        fs.writeFileSync(tokenPath, generated, { encoding: 'utf-8', mode: 0o600 });
+    }
+    catch {
+        // keep the generated token for this process even if persistence fails
+    }
+    return generated;
+}
+function tailscaleIpv4() {
+    const exe = process.platform === 'win32' ? 'tailscale.exe' : 'tailscale';
+    try {
+        const result = (0, child_process_1.spawnSync)(exe, ['ip', '-4'], { encoding: 'utf-8', windowsHide: true, timeout: 3000 });
+        if (result.error || result.status !== 0)
+            return null;
+        const lines = String(result.stdout || '').split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+        return lines[0] || null;
+    }
+    catch {
+        return null;
+    }
+}
+function lanIpv4() {
+    const interfaces = os.networkInterfaces();
+    const candidates = [];
+    for (const name of Object.keys(interfaces)) {
+        for (const info of interfaces[name] || []) {
+            if (info.family !== 'IPv4' || info.internal)
+                continue;
+            if (/^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(info.address))
+                candidates.push(info.address);
+        }
+    }
+    return candidates.sort()[0] || null;
+}
+function pairingHost() {
+    return tailscaleIpv4() || lanIpv4() || '127.0.0.1';
+}
+function buildPairingUrl(session) {
+    const query = new URLSearchParams({
+        token: session.token,
+        host: session.hostname,
+        port: String(session.port),
+        pairingId: session.pairingId,
+        issuedAt: String(session.issuedAt),
+        expiresAt: String(session.expiresAt),
+    });
+    return `newmark-pair://${session.host}:${session.port}?${query.toString()}`;
+}
+function createPairingSession(root, ttlMs = exports.MOBILE_PAIRING_TTL_MS) {
+    const token = ensureMobileToken(root);
+    const host = pairingHost();
+    const now = Date.now();
+    const session = {
+        pairingId: (0, crypto_1.randomBytes)(12).toString('hex'),
+        token,
+        host,
+        hostname: os.hostname(),
+        port: exports.MOBILE_PORT,
+        issuedAt: now,
+        expiresAt: now + Math.max(1000, Number(ttlMs) || exports.MOBILE_PAIRING_TTL_MS),
+        url: '',
+        confirmed: false,
+        confirmedAt: 0,
+    };
+    session.url = buildPairingUrl(session);
+    writePairingState(root, session);
+    return session;
+}
+function pairingUrl(root) {
+    return createPairingSession(root).url;
+}
+function pairingTokenPath(root) {
+    return path.join(root, exports.MOBILE_TOKEN_FILENAME);
+}
+function pairingStatus(root) {
+    const state = readPairingState(root);
+    if (!state) {
+        return { pairingId: '', issuedAt: 0, expiresAt: 0, confirmed: false, confirmedAt: 0, active: false, expired: true };
+    }
+    const now = Date.now();
+    const confirmed = state.confirmed === true;
+    const expired = now >= Number(state.expiresAt || 0);
+    return {
+        pairingId: state.pairingId,
+        issuedAt: Number(state.issuedAt || 0),
+        expiresAt: Number(state.expiresAt || 0),
+        confirmed,
+        confirmedAt: Number(state.confirmedAt || 0),
+        active: !confirmed && !expired,
+        expired: !confirmed && expired,
+    };
+}
+function confirmPairing(root, pairingId, token) {
+    const state = readPairingState(root);
+    const status = pairingStatus(root);
+    if (!state || !state.pairingId) {
+        return { ok: false, error: 'No pairing window is active.', status };
+    }
+    if (state.token !== token) {
+        return { ok: false, error: 'Pairing token does not match.', status };
+    }
+    if (state.pairingId !== pairingId) {
+        return { ok: false, error: 'Pairing window is stale.', status };
+    }
+    if (status.expired) {
+        return { ok: false, error: 'Pairing window expired.', status };
+    }
+    if (status.confirmed) {
+        return { ok: true, status };
+    }
+    const updated = { ...state, confirmed: true, confirmedAt: Date.now() };
+    writePairingState(root, updated);
+    return { ok: true, status: pairingStatus(root) };
+}
+async function pairingQrDataUrl(root, ttlMs) {
+    const session = createPairingSession(root, ttlMs);
+    const dataUrl = await QRCode.toDataURL(session.url, {
+        width: 420,
+        margin: 1,
+        errorCorrectionLevel: 'M',
+        color: { dark: '#101828', light: '#FFFFFF' },
+    });
+    return { dataUrl, session };
+}
+async function pairingQrAscii(root, ttlMs) {
+    const session = createPairingSession(root, ttlMs);
+    const ascii = await QRCode.toString(session.url, {
+        type: 'terminal',
+        small: true,
+        errorCorrectionLevel: 'M',
+    });
+    return { ascii, session };
+}
+//# sourceMappingURL=mobilePairing.js.map

package/dist/core/subagent.d.ts

@@ -54,6 +54,10 @@ export interface SubagentInstance {
     name: string;
     conversationId: string;
     createdByAgentId: string;
+    /** Root Build Block that created this peer. Empty only for legacy/direct API records. */
+    buildRunId?: string;
+    /** Intelligence tier captured at creation so the enforced 4/16 ceiling is auditable. */
+    intelligenceTier?: string;
     prompt: string;
     model: string;
     inputMode: string;
@@ -172,7 +176,7 @@ export declare class SubagentManager {
     private running;
     private schedulingPaused;
     private nextSequence;
-    private readonly concurrency;
+    private concurrency;
     private executor?;
     private onChange?;
     private persist?;
@@ -186,9 +190,9 @@ export declare class SubagentManager {
     hasRecords(): boolean;
     reset(): void;
     constructor(options?: SubagentManagerOptions);
-    bind(options: Pick<SubagentManagerOptions, 'executor' | 'onChange' | 'persist' | 'onMailboxMessage' | 'onRootInboxMessage' | 'onSettled'>): void;
+    bind(options: Pick<SubagentManagerOptions, 'concurrency' | 'executor' | 'onChange' | 'persist' | 'onMailboxMessage' | 'onRootInboxMessage' | 'onSettled'>): void;
     removeRootInboxListener(listener: (message: SubagentRootMessage) => boolean): void;
-    create(name: string, prompt: string, model?: string, inputMode?: string, agentMode?: AgentMode, createdByAgentId?: string, flowName?: string, goalObjective?: string, flowPc?: number): string;
+    create(name: string, prompt: string, model?: string, inputMode?: string, agentMode?: AgentMode, createdByAgentId?: string, flowName?: string, goalObjective?: string, flowPc?: number, buildRunId?: string, intelligenceTier?: string): string;
     get(id: string): SubagentInstance | undefined;
     send(id: string, prompt: string): boolean;
     sendMessage(fromAgentId: string, toAgentId: string, body: string, kind?: SubagentMessageKind, details?: {
@@ -231,6 +235,9 @@ export declare class SubagentManager {
     boundedResultTranscript(idOrName: string): string;
     listActive(): SubagentInstance[];
     listAll(): SubagentInstance[];
+    activeCountForBuild(buildRunId: string): number;
+    setConcurrencyLimit(value: number): void;
+    concurrencyLimit(): number;
     pauseScheduling(): void;
     resumeScheduling(): void;
     isSchedulingPaused(): boolean;

package/dist/core/subagent.js

@@ -93,6 +93,8 @@ class SubagentManager {
         queueMicrotask(() => this.pump());
     }
     bind(options) {
+        if (options.concurrency !== undefined)
+            this.setConcurrencyLimit(options.concurrency);
         if (options.executor)
             this.executor = options.executor;
         if (options.onChange)
@@ -115,16 +117,16 @@ class SubagentManager {
     removeRootInboxListener(listener) {
         this.rootInboxListeners.delete(listener);
     }
-    create(name, prompt, model, inputMode, agentMode = 'build', createdByAgentId = this.rootAgentId, flowName = '', goalObjective = '', flowPc = 0) {
+    create(name, prompt, model, inputMode, agentMode = 'build', createdByAgentId = this.rootAgentId, flowName = '', goalObjective = '', flowPc = 0, buildRunId = '', intelligenceTier = '') {
         const id = (0, crypto_1.randomUUID)();
         const shortId = id.replace(/-/g, '').slice(0, 8);
         const slug = natureSlug(name);
-        // The Agent-facing name is the caller's stable, human-readable label and is
-        // deliberately decoupled from the identity. The UUID and its short form are
-        // the only identity-bearing fields; the UI renders the short-id-qualified
-        // display name while Agent tool interactions accept both name and id.
-        const displayName = `${slug}-${shortId}`;
-        const qualifiedName = `${displayName}--${id}`;
+        // The monitoring label is exactly the caller-created human-readable name.
+        // UUID-bearing identity stays in id/qualifiedName and is never appended to
+        // the right-sidebar title.
+        const createdName = String(name || 'SubAgent').replace(/\s+/g, ' ').trim().slice(0, 160) || 'SubAgent';
+        const displayName = createdName;
+        const qualifiedName = `${slug}--${id}`;
         const stamp = now();
         const record = {
             id,
@@ -132,9 +134,11 @@ class SubagentManager {
             natureSlug: slug,
             displayName,
             qualifiedName,
-            name: slug,
+            name: createdName,
             conversationId: this.conversationId,
             createdByAgentId,
+            buildRunId: String(buildRunId || '').trim() || undefined,
+            intelligenceTier: String(intelligenceTier || '').trim() || undefined,
             prompt,
             model: model || 'default',
             inputMode: inputMode || 'guide',
@@ -504,6 +508,17 @@ class SubagentManager {
     }
     listActive() { return this.listAll().filter(item => item.status !== 'closed'); }
     listAll() { return [...this.subs.values()].map(cloneRecord); }
+    activeCountForBuild(buildRunId) {
+        const target = String(buildRunId || '').trim();
+        if (!target)
+            return 0;
+        return [...this.subs.values()].filter(record => record.buildRunId === target && (record.status === 'queued' || record.status === 'working')).length;
+    }
+    setConcurrencyLimit(value) {
+        this.concurrency = Math.max(1, Math.min(16, Math.floor(Number(value) || 4)));
+        this.pump();
+    }
+    concurrencyLimit() { return this.concurrency; }
     pauseScheduling() {
         if (this.schedulingPaused)
             return;