@intent-systems/nexus 2026.1.5-3

package/dist/infra/heartbeat-runner.js

@@ -0,0 +1,458 @@
+import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { DEFAULT_HEARTBEAT_ACK_MAX_CHARS, HEARTBEAT_PROMPT, stripHeartbeatToken, } from "../auto-reply/heartbeat.js";
+import { getReplyFromConfig } from "../auto-reply/reply.js";
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath, saveSessionStore, } from "../config/sessions.js";
+import { sendMessageDiscord } from "../discord/send.js";
+import { sendMessageIMessage } from "../imessage/send.js";
+import { formatErrorMessage } from "../infra/errors.js";
+import { createSubsystemLogger } from "../logging.js";
+import { getQueueSize } from "../process/command-queue.js";
+import { webAuthExists } from "../providers/web/index.js";
+import { defaultRuntime } from "../runtime.js";
+import { sendMessageSignal } from "../signal/send.js";
+import { sendMessageSlack } from "../slack/send.js";
+import { sendMessageTelegram } from "../telegram/send.js";
+import { normalizeE164 } from "../utils.js";
+import { getActiveWebListener } from "../web/active-listener.js";
+import { sendMessageWhatsApp } from "../web/outbound.js";
+import { emitHeartbeatEvent } from "./heartbeat-events.js";
+import { requestHeartbeatNow, setHeartbeatWakeHandler, } from "./heartbeat-wake.js";
+const log = createSubsystemLogger("gateway/heartbeat");
+let heartbeatsEnabled = true;
+export function setHeartbeatsEnabled(enabled) {
+    heartbeatsEnabled = enabled;
+}
+export function resolveHeartbeatIntervalMs(cfg, overrideEvery) {
+    const raw = overrideEvery ?? cfg.agent?.heartbeat?.every;
+    if (!raw)
+        return null;
+    const trimmed = String(raw).trim();
+    if (!trimmed)
+        return null;
+    let ms;
+    try {
+        ms = parseDurationMs(trimmed, { defaultUnit: "m" });
+    }
+    catch {
+        return null;
+    }
+    if (ms <= 0)
+        return null;
+    return ms;
+}
+export function resolveHeartbeatPrompt(cfg) {
+    const raw = cfg.agent?.heartbeat?.prompt;
+    const trimmed = typeof raw === "string" ? raw.trim() : "";
+    return trimmed || HEARTBEAT_PROMPT;
+}
+function resolveHeartbeatAckMaxChars(cfg) {
+    return Math.max(0, cfg.agent?.heartbeat?.ackMaxChars ?? DEFAULT_HEARTBEAT_ACK_MAX_CHARS);
+}
+function resolveHeartbeatSession(cfg) {
+    const sessionCfg = cfg.session;
+    const scope = sessionCfg?.scope ?? "per-sender";
+    const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
+    const sessionKey = scope === "global" ? "global" : mainKey;
+    const storePath = resolveStorePath(sessionCfg?.store);
+    const store = loadSessionStore(storePath);
+    const entry = store[sessionKey];
+    return { sessionKey, storePath, store, entry };
+}
+function resolveHeartbeatReplyPayload(replyResult) {
+    if (!replyResult)
+        return undefined;
+    if (!Array.isArray(replyResult))
+        return replyResult;
+    for (let idx = replyResult.length - 1; idx >= 0; idx -= 1) {
+        const payload = replyResult[idx];
+        if (!payload)
+            continue;
+        if (payload.text ||
+            payload.mediaUrl ||
+            (payload.mediaUrls && payload.mediaUrls.length > 0)) {
+            return payload;
+        }
+    }
+    return undefined;
+}
+function resolveHeartbeatSender(params) {
+    const { allowFrom, lastTo, lastProvider } = params;
+    const candidates = [
+        lastTo?.trim(),
+        lastProvider === "telegram" && lastTo ? `telegram:${lastTo}` : undefined,
+        lastProvider === "whatsapp" && lastTo ? `whatsapp:${lastTo}` : undefined,
+    ].filter((val) => Boolean(val?.trim()));
+    const allowList = allowFrom
+        .map((entry) => String(entry))
+        .filter((entry) => entry && entry !== "*");
+    if (allowFrom.includes("*")) {
+        return candidates[0] ?? "heartbeat";
+    }
+    if (candidates.length > 0 && allowList.length > 0) {
+        const matched = candidates.find((candidate) => allowList.includes(candidate));
+        if (matched)
+            return matched;
+    }
+    if (candidates.length > 0 && allowList.length === 0) {
+        return candidates[0];
+    }
+    if (allowList.length > 0)
+        return allowList[0];
+    return candidates[0] ?? "heartbeat";
+}
+async function resolveWhatsAppReadiness(cfg, deps) {
+    if (cfg.web?.enabled === false) {
+        return { ok: false, reason: "whatsapp-disabled" };
+    }
+    const authExists = await (deps?.webAuthExists ?? webAuthExists)();
+    if (!authExists) {
+        return { ok: false, reason: "whatsapp-not-linked" };
+    }
+    const listenerActive = deps?.hasActiveWebListener
+        ? deps.hasActiveWebListener()
+        : Boolean(getActiveWebListener());
+    if (!listenerActive) {
+        return { ok: false, reason: "whatsapp-not-running" };
+    }
+    return { ok: true, reason: "ok" };
+}
+export function resolveHeartbeatDeliveryTarget(params) {
+    const { cfg, entry } = params;
+    const rawTarget = cfg.agent?.heartbeat?.target;
+    const target = rawTarget === "whatsapp" ||
+        rawTarget === "telegram" ||
+        rawTarget === "discord" ||
+        rawTarget === "slack" ||
+        rawTarget === "signal" ||
+        rawTarget === "imessage" ||
+        rawTarget === "none" ||
+        rawTarget === "last"
+        ? rawTarget
+        : "last";
+    if (target === "none") {
+        return { provider: "none", reason: "target-none" };
+    }
+    const explicitTo = typeof cfg.agent?.heartbeat?.to === "string" &&
+        cfg.agent.heartbeat.to.trim()
+        ? cfg.agent.heartbeat.to.trim()
+        : undefined;
+    const lastProvider = entry?.lastProvider && entry.lastProvider !== "webchat"
+        ? entry.lastProvider
+        : undefined;
+    const lastTo = typeof entry?.lastTo === "string" ? entry.lastTo.trim() : "";
+    const provider = target === "last"
+        ? lastProvider
+        : target === "whatsapp" ||
+            target === "telegram" ||
+            target === "discord" ||
+            target === "slack" ||
+            target === "signal" ||
+            target === "imessage"
+            ? target
+            : undefined;
+    const to = explicitTo ||
+        (provider && lastProvider === provider ? lastTo : undefined) ||
+        (target === "last" ? lastTo : undefined);
+    if (!provider || !to) {
+        return { provider: "none", reason: "no-target" };
+    }
+    if (provider !== "whatsapp") {
+        return { provider, to };
+    }
+    const rawAllow = cfg.whatsapp?.allowFrom ?? [];
+    if (rawAllow.includes("*"))
+        return { provider, to };
+    const allowFrom = rawAllow
+        .map((val) => normalizeE164(val))
+        .filter((val) => val.length > 1);
+    if (allowFrom.length === 0)
+        return { provider, to };
+    const normalized = normalizeE164(to);
+    if (allowFrom.includes(normalized))
+        return { provider, to: normalized };
+    return { provider, to: allowFrom[0], reason: "allowFrom-fallback" };
+}
+async function restoreHeartbeatUpdatedAt(params) {
+    const { storePath, sessionKey, updatedAt } = params;
+    if (typeof updatedAt !== "number")
+        return;
+    const store = loadSessionStore(storePath);
+    const entry = store[sessionKey];
+    if (!entry)
+        return;
+    if (entry.updatedAt === updatedAt)
+        return;
+    store[sessionKey] = { ...entry, updatedAt };
+    await saveSessionStore(storePath, store);
+}
+function normalizeHeartbeatReply(payload, responsePrefix, ackMaxChars) {
+    const stripped = stripHeartbeatToken(payload.text, {
+        mode: "heartbeat",
+        maxAckChars: ackMaxChars,
+    });
+    const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+    if (stripped.shouldSkip && !hasMedia) {
+        return {
+            shouldSkip: true,
+            text: "",
+            hasMedia,
+        };
+    }
+    let finalText = stripped.text;
+    if (responsePrefix && finalText && !finalText.startsWith(responsePrefix)) {
+        finalText = `${responsePrefix} ${finalText}`;
+    }
+    return { shouldSkip: false, text: finalText, hasMedia };
+}
+async function deliverHeartbeatReply(params) {
+    const { provider, to, text, mediaUrls, deps, textLimit } = params;
+    if (provider === "whatsapp") {
+        if (mediaUrls.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await deps.sendWhatsApp(to, chunk, { verbose: false });
+            }
+            return;
+        }
+        let first = true;
+        for (const url of mediaUrls) {
+            const caption = first ? text : "";
+            first = false;
+            await deps.sendWhatsApp(to, caption, { verbose: false, mediaUrl: url });
+        }
+        return;
+    }
+    if (provider === "signal") {
+        if (mediaUrls.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await deps.sendSignal(to, chunk);
+            }
+            return;
+        }
+        let first = true;
+        for (const url of mediaUrls) {
+            const caption = first ? text : "";
+            first = false;
+            await deps.sendSignal(to, caption, { mediaUrl: url });
+        }
+        return;
+    }
+    if (provider === "imessage") {
+        if (mediaUrls.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await deps.sendIMessage(to, chunk);
+            }
+            return;
+        }
+        let first = true;
+        for (const url of mediaUrls) {
+            const caption = first ? text : "";
+            first = false;
+            await deps.sendIMessage(to, caption, { mediaUrl: url });
+        }
+        return;
+    }
+    if (provider === "telegram") {
+        if (mediaUrls.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await deps.sendTelegram(to, chunk, { verbose: false });
+            }
+            return;
+        }
+        let first = true;
+        for (const url of mediaUrls) {
+            const caption = first ? text : "";
+            first = false;
+            await deps.sendTelegram(to, caption, { verbose: false, mediaUrl: url });
+        }
+        return;
+    }
+    if (provider === "slack") {
+        if (mediaUrls.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await deps.sendSlack(to, chunk);
+            }
+            return;
+        }
+        let first = true;
+        for (const url of mediaUrls) {
+            const caption = first ? text : "";
+            first = false;
+            await deps.sendSlack(to, caption, { mediaUrl: url });
+        }
+        return;
+    }
+    // provider is "discord" here
+    if (mediaUrls.length === 0) {
+        await deps.sendDiscord(to, text, { verbose: false });
+        return;
+    }
+    let first = true;
+    for (const url of mediaUrls) {
+        const caption = first ? text : "";
+        first = false;
+        await deps.sendDiscord(to, caption, { verbose: false, mediaUrl: url });
+    }
+}
+export async function runHeartbeatOnce(opts) {
+    const cfg = opts.cfg ?? loadConfig();
+    if (!heartbeatsEnabled) {
+        return { status: "skipped", reason: "disabled" };
+    }
+    if (!resolveHeartbeatIntervalMs(cfg)) {
+        return { status: "skipped", reason: "disabled" };
+    }
+    const queueSize = (opts.deps?.getQueueSize ?? getQueueSize)("main");
+    if (queueSize > 0) {
+        return { status: "skipped", reason: "requests-in-flight" };
+    }
+    const startedAt = opts.deps?.nowMs?.() ?? Date.now();
+    const { entry, sessionKey, storePath } = resolveHeartbeatSession(cfg);
+    const previousUpdatedAt = entry?.updatedAt;
+    const allowFrom = cfg.whatsapp?.allowFrom ?? [];
+    const sender = resolveHeartbeatSender({
+        allowFrom,
+        lastTo: entry?.lastTo,
+        lastProvider: entry?.lastProvider,
+    });
+    const prompt = resolveHeartbeatPrompt(cfg);
+    const ctx = {
+        Body: prompt,
+        From: sender,
+        To: sender,
+        Provider: "heartbeat",
+    };
+    try {
+        const replyResult = await getReplyFromConfig(ctx, { isHeartbeat: true }, cfg);
+        const replyPayload = resolveHeartbeatReplyPayload(replyResult);
+        if (!replyPayload ||
+            (!replyPayload.text &&
+                !replyPayload.mediaUrl &&
+                !replyPayload.mediaUrls?.length)) {
+            await restoreHeartbeatUpdatedAt({
+                storePath,
+                sessionKey,
+                updatedAt: previousUpdatedAt,
+            });
+            emitHeartbeatEvent({
+                status: "ok-empty",
+                reason: opts.reason,
+                durationMs: Date.now() - startedAt,
+            });
+            return { status: "ran", durationMs: Date.now() - startedAt };
+        }
+        const ackMaxChars = resolveHeartbeatAckMaxChars(cfg);
+        const normalized = normalizeHeartbeatReply(replyPayload, cfg.messages?.responsePrefix, ackMaxChars);
+        if (normalized.shouldSkip && !normalized.hasMedia) {
+            await restoreHeartbeatUpdatedAt({
+                storePath,
+                sessionKey,
+                updatedAt: previousUpdatedAt,
+            });
+            emitHeartbeatEvent({
+                status: "ok-token",
+                reason: opts.reason,
+                durationMs: Date.now() - startedAt,
+            });
+            return { status: "ran", durationMs: Date.now() - startedAt };
+        }
+        const delivery = resolveHeartbeatDeliveryTarget({ cfg, entry });
+        const mediaUrls = replyPayload.mediaUrls ??
+            (replyPayload.mediaUrl ? [replyPayload.mediaUrl] : []);
+        if (delivery.provider === "none" || !delivery.to) {
+            emitHeartbeatEvent({
+                status: "skipped",
+                reason: delivery.reason ?? "no-target",
+                preview: normalized.text?.slice(0, 200),
+                durationMs: Date.now() - startedAt,
+                hasMedia: mediaUrls.length > 0,
+            });
+            return { status: "ran", durationMs: Date.now() - startedAt };
+        }
+        if (delivery.provider === "whatsapp") {
+            const readiness = await resolveWhatsAppReadiness(cfg, opts.deps);
+            if (!readiness.ok) {
+                emitHeartbeatEvent({
+                    status: "skipped",
+                    reason: readiness.reason,
+                    preview: normalized.text?.slice(0, 200),
+                    durationMs: Date.now() - startedAt,
+                    hasMedia: mediaUrls.length > 0,
+                });
+                log.info("heartbeat: whatsapp not ready", {
+                    reason: readiness.reason,
+                });
+                return { status: "skipped", reason: readiness.reason };
+            }
+        }
+        const deps = {
+            sendWhatsApp: opts.deps?.sendWhatsApp ?? sendMessageWhatsApp,
+            sendTelegram: opts.deps?.sendTelegram ?? sendMessageTelegram,
+            sendDiscord: opts.deps?.sendDiscord ?? sendMessageDiscord,
+            sendSlack: opts.deps?.sendSlack ?? sendMessageSlack,
+            sendSignal: opts.deps?.sendSignal ?? sendMessageSignal,
+            sendIMessage: opts.deps?.sendIMessage ?? sendMessageIMessage,
+        };
+        const textLimit = resolveTextChunkLimit(cfg, delivery.provider);
+        await deliverHeartbeatReply({
+            provider: delivery.provider,
+            to: delivery.to,
+            text: normalized.text,
+            mediaUrls,
+            textLimit,
+            deps,
+        });
+        emitHeartbeatEvent({
+            status: "sent",
+            to: delivery.to,
+            preview: normalized.text?.slice(0, 200),
+            durationMs: Date.now() - startedAt,
+            hasMedia: mediaUrls.length > 0,
+        });
+        return { status: "ran", durationMs: Date.now() - startedAt };
+    }
+    catch (err) {
+        const reason = formatErrorMessage(err);
+        emitHeartbeatEvent({
+            status: "failed",
+            reason,
+            durationMs: Date.now() - startedAt,
+        });
+        log.error(`heartbeat failed: ${reason}`, { error: reason });
+        return { status: "failed", reason };
+    }
+}
+export function startHeartbeatRunner(opts) {
+    const cfg = opts.cfg ?? loadConfig();
+    const intervalMs = resolveHeartbeatIntervalMs(cfg);
+    if (!intervalMs) {
+        log.info("heartbeat: disabled", { enabled: false });
+    }
+    const runtime = opts.runtime ?? defaultRuntime;
+    const run = async (params) => {
+        const res = await runHeartbeatOnce({
+            cfg,
+            reason: params?.reason,
+            deps: { runtime },
+        });
+        return res;
+    };
+    setHeartbeatWakeHandler(async (params) => run({ reason: params.reason }));
+    let timer = null;
+    if (intervalMs) {
+        timer = setInterval(() => {
+            requestHeartbeatNow({ reason: "interval", coalesceMs: 0 });
+        }, intervalMs);
+        timer.unref?.();
+        log.info("heartbeat: started", { intervalMs });
+    }
+    const cleanup = () => {
+        setHeartbeatWakeHandler(null);
+        if (timer)
+            clearInterval(timer);
+        timer = null;
+    };
+    opts.abortSignal?.addEventListener("abort", cleanup, { once: true });
+    return { stop: cleanup };
+}

package/dist/infra/heartbeat-wake.js

@@ -0,0 +1,61 @@
+let handler = null;
+let pendingReason = null;
+let scheduled = false;
+let running = false;
+let timer = null;
+const DEFAULT_COALESCE_MS = 250;
+const DEFAULT_RETRY_MS = 1_000;
+function schedule(coalesceMs) {
+    if (timer)
+        return;
+    timer = setTimeout(async () => {
+        timer = null;
+        scheduled = false;
+        const active = handler;
+        if (!active)
+            return;
+        if (running) {
+            scheduled = true;
+            schedule(coalesceMs);
+            return;
+        }
+        const reason = pendingReason;
+        pendingReason = null;
+        running = true;
+        try {
+            const res = await active({ reason: reason ?? undefined });
+            if (res.status === "skipped" && res.reason === "requests-in-flight") {
+                // The main lane is busy; retry soon.
+                pendingReason = reason ?? "retry";
+                schedule(DEFAULT_RETRY_MS);
+            }
+        }
+        catch (err) {
+            pendingReason = reason ?? "retry";
+            schedule(DEFAULT_RETRY_MS);
+            throw err;
+        }
+        finally {
+            running = false;
+            if (pendingReason || scheduled)
+                schedule(coalesceMs);
+        }
+    }, coalesceMs);
+    timer.unref?.();
+}
+export function setHeartbeatWakeHandler(next) {
+    handler = next;
+    if (handler && pendingReason) {
+        schedule(DEFAULT_COALESCE_MS);
+    }
+}
+export function requestHeartbeatNow(opts) {
+    pendingReason = opts?.reason ?? pendingReason ?? "requested";
+    schedule(opts?.coalesceMs ?? DEFAULT_COALESCE_MS);
+}
+export function hasHeartbeatWakeHandler() {
+    return handler !== null;
+}
+export function hasPendingHeartbeatWake() {
+    return pendingReason !== null || Boolean(timer) || scheduled;
+}

package/dist/infra/is-main.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+function normalizePathCandidate(candidate, cwd) {
+    if (!candidate)
+        return undefined;
+    const resolved = path.resolve(cwd, candidate);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function isMainModule({ currentFile, argv = process.argv, env = process.env, cwd = process.cwd(), }) {
+    const normalizedCurrent = normalizePathCandidate(currentFile, cwd);
+    const normalizedArgv1 = normalizePathCandidate(argv[1], cwd);
+    if (normalizedCurrent &&
+        normalizedArgv1 &&
+        normalizedCurrent === normalizedArgv1) {
+        return true;
+    }
+    // PM2 runs the script via an internal wrapper; `argv[1]` points at the wrapper.
+    // PM2 exposes the actual script path in `pm_exec_path`.
+    const normalizedPmExecPath = normalizePathCandidate(env.pm_exec_path, cwd);
+    if (normalizedCurrent &&
+        normalizedPmExecPath &&
+        normalizedCurrent === normalizedPmExecPath) {
+        return true;
+    }
+    // Fallback: basename match (relative paths, symlinked bins).
+    if (normalizedCurrent &&
+        normalizedArgv1 &&
+        path.basename(normalizedCurrent) === path.basename(normalizedArgv1)) {
+        return true;
+    }
+    return false;
+}

package/dist/infra/json-file.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+export function loadJsonFile(pathname) {
+    try {
+        if (!fs.existsSync(pathname))
+            return undefined;
+        const raw = fs.readFileSync(pathname, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveJsonFile(pathname, data) {
+    const dir = path.dirname(pathname);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(pathname, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    fs.chmodSync(pathname, 0o600);
+}

package/dist/infra/machine-name.js

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+import os from "node:os";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+let cachedPromise = null;
+async function tryScutil(key) {
+    try {
+        const { stdout } = await execFileAsync("/usr/sbin/scutil", ["--get", key], {
+            timeout: 1000,
+            windowsHide: true,
+        });
+        const value = String(stdout ?? "").trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function fallbackHostName() {
+    return (os
+        .hostname()
+        .replace(/\.local$/i, "")
+        .trim() || "nexus");
+}
+export async function getMachineDisplayName() {
+    if (cachedPromise)
+        return cachedPromise;
+    cachedPromise = (async () => {
+        if (process.platform === "darwin") {
+            const computerName = await tryScutil("ComputerName");
+            if (computerName)
+                return computerName;
+            const localHostName = await tryScutil("LocalHostName");
+            if (localHostName)
+                return localHostName;
+        }
+        return fallbackHostName();
+    })();
+    return cachedPromise;
+}

package/dist/infra/nexus-root.js

@@ -0,0 +1,56 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+async function readPackageName(dir) {
+    try {
+        const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function findPackageRoot(startDir, maxDepth = 12) {
+    let current = path.resolve(startDir);
+    for (let i = 0; i < maxDepth; i += 1) {
+        const name = await readPackageName(current);
+        if (name === "nexus")
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function candidateDirsFromArgv1(argv1) {
+    const normalized = path.resolve(argv1);
+    const candidates = [path.dirname(normalized)];
+    const parts = normalized.split(path.sep);
+    const binIndex = parts.lastIndexOf(".bin");
+    if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+        const binName = path.basename(normalized);
+        const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+        candidates.push(path.join(nodeModulesDir, binName));
+    }
+    return candidates;
+}
+export async function resolveNexusPackageRoot(opts) {
+    const candidates = [];
+    if (opts.moduleUrl) {
+        candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+    }
+    if (opts.argv1) {
+        candidates.push(...candidateDirsFromArgv1(opts.argv1));
+    }
+    if (opts.cwd) {
+        candidates.push(opts.cwd);
+    }
+    for (const candidate of candidates) {
+        const found = await findPackageRoot(candidate);
+        if (found)
+            return found;
+    }
+    return null;
+}