@intent-systems/nexus 2026.1.5-3

package/dist/process/command-queue.js

@@ -0,0 +1,97 @@
+// Minimal in-process queue to serialize command executions.
+// Default lane ("main") preserves the existing behavior. Additional lanes allow
+// low-risk parallelism (e.g. cron jobs) without interleaving stdin / logs for
+// the main auto-reply workflow.
+const lanes = new Map();
+function getLaneState(lane) {
+    const existing = lanes.get(lane);
+    if (existing)
+        return existing;
+    const created = {
+        lane,
+        queue: [],
+        active: 0,
+        maxConcurrent: 1,
+        draining: false,
+    };
+    lanes.set(lane, created);
+    return created;
+}
+function drainLane(lane) {
+    const state = getLaneState(lane);
+    if (state.draining)
+        return;
+    state.draining = true;
+    const pump = () => {
+        while (state.active < state.maxConcurrent && state.queue.length > 0) {
+            const entry = state.queue.shift();
+            const waitedMs = Date.now() - entry.enqueuedAt;
+            if (waitedMs >= entry.warnAfterMs) {
+                entry.onWait?.(waitedMs, state.queue.length);
+            }
+            state.active += 1;
+            void (async () => {
+                try {
+                    const result = await entry.task();
+                    state.active -= 1;
+                    pump();
+                    entry.resolve(result);
+                }
+                catch (err) {
+                    state.active -= 1;
+                    pump();
+                    entry.reject(err);
+                }
+            })();
+        }
+        state.draining = false;
+    };
+    pump();
+}
+export function setCommandLaneConcurrency(lane, maxConcurrent) {
+    const cleaned = lane.trim() || "main";
+    const state = getLaneState(cleaned);
+    state.maxConcurrent = Math.max(1, Math.floor(maxConcurrent));
+    drainLane(cleaned);
+}
+export function enqueueCommandInLane(lane, task, opts) {
+    const cleaned = lane.trim() || "main";
+    const warnAfterMs = opts?.warnAfterMs ?? 2_000;
+    const state = getLaneState(cleaned);
+    return new Promise((resolve, reject) => {
+        state.queue.push({
+            task: () => task(),
+            resolve: (value) => resolve(value),
+            reject,
+            enqueuedAt: Date.now(),
+            warnAfterMs,
+            onWait: opts?.onWait,
+        });
+        drainLane(cleaned);
+    });
+}
+export function enqueueCommand(task, opts) {
+    return enqueueCommandInLane("main", task, opts);
+}
+export function getQueueSize(lane = "main") {
+    const state = lanes.get(lane);
+    if (!state)
+        return 0;
+    return state.queue.length + state.active;
+}
+export function getTotalQueueSize() {
+    let total = 0;
+    for (const s of lanes.values()) {
+        total += s.queue.length + s.active;
+    }
+    return total;
+}
+export function clearCommandLane(lane = "main") {
+    const cleaned = lane.trim() || "main";
+    const state = lanes.get(cleaned);
+    if (!state)
+        return 0;
+    const removed = state.queue.length;
+    state.queue.length = 0;
+    return removed;
+}

package/dist/process/exec.js

@@ -0,0 +1,75 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { danger, shouldLogVerbose } from "../globals.js";
+import { logDebug, logError } from "../logger.js";
+const execFileAsync = promisify(execFile);
+// Simple promise-wrapped execFile with optional verbosity logging.
+export async function runExec(command, args, opts = 10_000) {
+    const options = typeof opts === "number"
+        ? { timeout: opts, encoding: "utf8" }
+        : {
+            timeout: opts.timeoutMs,
+            maxBuffer: opts.maxBuffer,
+            encoding: "utf8",
+        };
+    try {
+        const { stdout, stderr } = await execFileAsync(command, args, options);
+        if (shouldLogVerbose()) {
+            if (stdout.trim())
+                logDebug(stdout.trim());
+            if (stderr.trim())
+                logError(stderr.trim());
+        }
+        return { stdout, stderr };
+    }
+    catch (err) {
+        if (shouldLogVerbose()) {
+            logError(danger(`Command failed: ${command} ${args.join(" ")}`));
+        }
+        throw err;
+    }
+}
+export async function runCommandWithTimeout(argv, optionsOrTimeout) {
+    const options = typeof optionsOrTimeout === "number"
+        ? { timeoutMs: optionsOrTimeout }
+        : optionsOrTimeout;
+    const { timeoutMs, cwd, input, env } = options;
+    // Spawn with inherited stdin (TTY) so tools like `pi` stay interactive when needed.
+    return await new Promise((resolve, reject) => {
+        const child = spawn(argv[0], argv.slice(1), {
+            stdio: [input ? "pipe" : "inherit", "pipe", "pipe"],
+            cwd,
+            env: env ? { ...process.env, ...env } : process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        if (input && child.stdin) {
+            child.stdin.write(input);
+            child.stdin.end();
+        }
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += d.toString();
+        });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ stdout, stderr, code, signal, killed: child.killed });
+        });
+    });
+}

package/dist/provider-web.js

@@ -0,0 +1,8 @@
+// Barrel exports for the web provider pieces. Splitting the original 900+ line
+// module keeps responsibilities small and testable without changing the public API.
+export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, monitorWebProvider, resolveHeartbeatRecipients, runWebHeartbeatOnce, } from "./web/auto-reply.js";
+export { extractMediaPlaceholder, extractText, monitorWebInbox, } from "./web/inbound.js";
+export { loginWeb } from "./web/login.js";
+export { loadWebMedia, optimizeImageToJpeg } from "./web/media.js";
+export { sendMessageWhatsApp } from "./web/outbound.js";
+export { createWaSocket, formatError, getStatusCode, logoutWeb, logWebSelfId, pickProvider, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "./web/session.js";

package/dist/providers/github-copilot-auth.js

@@ -0,0 +1,123 @@
+import { intro, note, outro, spinner } from "@clack/prompts";
+import { ensureAuthProfileStore, upsertAuthProfile } from "../agents/auth-profiles.js";
+import { updateConfig } from "../commands/models/shared.js";
+import { applyAuthProfileConfig } from "../commands/onboard-auth.js";
+import { CONFIG_PATH_NEXUS } from "../config/config.js";
+const CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const DEVICE_CODE_URL = "https://github.com/login/device/code";
+const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
+function parseJsonResponse(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Unexpected response from GitHub");
+    }
+    return value;
+}
+async function requestDeviceCode(params) {
+    const body = new URLSearchParams({
+        client_id: CLIENT_ID,
+        scope: params.scope,
+    });
+    const res = await fetch(DEVICE_CODE_URL, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body,
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub device code failed: HTTP ${res.status}`);
+    }
+    const json = parseJsonResponse(await res.json());
+    if (!json.device_code || !json.user_code || !json.verification_uri) {
+        throw new Error("GitHub device code response missing fields");
+    }
+    return json;
+}
+async function pollForAccessToken(params) {
+    const bodyBase = new URLSearchParams({
+        client_id: CLIENT_ID,
+        device_code: params.deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    });
+    while (Date.now() < params.expiresAt) {
+        const res = await fetch(ACCESS_TOKEN_URL, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: bodyBase,
+        });
+        if (!res.ok) {
+            throw new Error(`GitHub device token failed: HTTP ${res.status}`);
+        }
+        const json = parseJsonResponse(await res.json());
+        if ("access_token" in json && typeof json.access_token === "string") {
+            return json.access_token;
+        }
+        const err = "error" in json ? json.error : "unknown";
+        if (err === "authorization_pending") {
+            await new Promise((r) => setTimeout(r, params.intervalMs));
+            continue;
+        }
+        if (err === "slow_down") {
+            await new Promise((r) => setTimeout(r, params.intervalMs + 2000));
+            continue;
+        }
+        if (err === "expired_token") {
+            throw new Error("GitHub device code expired; run login again");
+        }
+        if (err === "access_denied") {
+            throw new Error("GitHub login cancelled");
+        }
+        throw new Error(`GitHub device flow error: ${err}`);
+    }
+    throw new Error("GitHub device code expired; run login again");
+}
+export async function githubCopilotLoginCommand(opts, runtime) {
+    if (!process.stdin.isTTY) {
+        throw new Error("github-copilot login requires an interactive TTY.");
+    }
+    intro("GitHub Copilot login");
+    const profileId = opts.profileId?.trim() || "github-copilot:github";
+    const store = ensureAuthProfileStore(undefined, {
+        allowKeychainPrompt: false,
+    });
+    if (store.profiles[profileId] && !opts.yes) {
+        note(`Auth profile already exists: ${profileId}\nRe-running will overwrite it.`, "Existing credentials");
+    }
+    const spin = spinner();
+    spin.start("Requesting device code from GitHub...");
+    const device = await requestDeviceCode({ scope: "read:user" });
+    spin.stop("Device code ready");
+    note([`Visit: ${device.verification_uri}`, `Code: ${device.user_code}`].join("\n"), "Authorize");
+    const expiresAt = Date.now() + device.expires_in * 1000;
+    const intervalMs = Math.max(1000, device.interval * 1000);
+    const polling = spinner();
+    polling.start("Waiting for GitHub authorization...");
+    const accessToken = await pollForAccessToken({
+        deviceCode: device.device_code,
+        intervalMs,
+        expiresAt,
+    });
+    polling.stop("GitHub access token acquired");
+    upsertAuthProfile({
+        profileId,
+        credential: {
+            type: "token",
+            provider: "github-copilot",
+            token: accessToken,
+            // GitHub device flow token doesn't reliably include expiry here.
+            // Leave expires unset; we'll exchange into Copilot token plus expiry later.
+        },
+    });
+    await updateConfig((cfg) => applyAuthProfileConfig(cfg, {
+        provider: "github-copilot",
+        profileId,
+        mode: "token",
+    }));
+    runtime.log(`Updated ${CONFIG_PATH_NEXUS}`);
+    runtime.log(`Auth profile: ${profileId} (github-copilot/token)`);
+    outro("Done");
+}

package/dist/providers/github-copilot-models.js

@@ -0,0 +1,35 @@
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 8192;
+// Copilot model ids vary by plan/org and can change.
+// We keep this list intentionally broad; if a model isn't available Copilot will
+// return an error and users can remove it from their config.
+const DEFAULT_MODEL_IDS = [
+    "gpt-4o",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "o1",
+    "o1-mini",
+    "o3-mini",
+];
+export function getDefaultCopilotModelIds() {
+    return [...DEFAULT_MODEL_IDS];
+}
+export function buildCopilotModelDefinition(modelId) {
+    const id = modelId.trim();
+    if (!id)
+        throw new Error("Model id required");
+    return {
+        id,
+        name: id,
+        // pi-coding-agent's registry schema doesn't know about a "github-copilot" API.
+        // We use OpenAI-compatible responses API, while keeping the provider id as
+        // "github-copilot" (pi-ai uses that to attach Copilot-specific headers).
+        api: "openai-responses",
+        reasoning: false,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxTokens: DEFAULT_MAX_TOKENS,
+    };
+}

package/dist/providers/github-copilot-token.js

@@ -0,0 +1,11 @@
+export const DEFAULT_COPILOT_API_BASE_URL = "https://api.individual.githubcopilot.com";
+export async function resolveCopilotApiToken(params) {
+    const env = params.env ?? process.env;
+    const baseUrl = env.COPILOT_API_BASE_URL?.trim() || DEFAULT_COPILOT_API_BASE_URL;
+    return {
+        token: params.githubToken,
+        expiresAt: Date.now() + 60 * 60 * 1000,
+        source: "github_token",
+        baseUrl,
+    };
+}

package/dist/providers/location.js

@@ -0,0 +1,48 @@
+function resolveLocation(location) {
+    const source = location.source ??
+        (location.isLive
+            ? "live"
+            : location.name || location.address
+                ? "place"
+                : "pin");
+    const isLive = Boolean(location.isLive ?? source === "live");
+    return { ...location, source, isLive };
+}
+function formatAccuracy(accuracy) {
+    if (!Number.isFinite(accuracy))
+        return "";
+    return ` ±${Math.round(accuracy ?? 0)}m`;
+}
+function formatCoords(latitude, longitude) {
+    return `${latitude.toFixed(6)}, ${longitude.toFixed(6)}`;
+}
+export function formatLocationText(location) {
+    const resolved = resolveLocation(location);
+    const coords = formatCoords(resolved.latitude, resolved.longitude);
+    const accuracy = formatAccuracy(resolved.accuracy);
+    const caption = resolved.caption?.trim();
+    let header = "";
+    if (resolved.source === "live" || resolved.isLive) {
+        header = `🛰 Live location: ${coords}${accuracy}`;
+    }
+    else if (resolved.name || resolved.address) {
+        const label = [resolved.name, resolved.address].filter(Boolean).join(" — ");
+        header = `📍 ${label} (${coords}${accuracy})`;
+    }
+    else {
+        header = `📍 ${coords}${accuracy}`;
+    }
+    return caption ? `${header}\n${caption}` : header;
+}
+export function toLocationContext(location) {
+    const resolved = resolveLocation(location);
+    return {
+        LocationLat: resolved.latitude,
+        LocationLon: resolved.longitude,
+        LocationAccuracy: resolved.accuracy,
+        LocationName: resolved.name,
+        LocationAddress: resolved.address,
+        LocationSource: resolved.source,
+        LocationIsLive: resolved.isLive,
+    };
+}

package/dist/providers/web/index.js

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export { createWaSocket, loginWeb, logWebSelfId, monitorWebInbox, monitorWebProvider, pickProvider, sendMessageWhatsApp, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "../../provider-web.js";

package/dist/runtime.js

@@ -0,0 +1,8 @@
+export const defaultRuntime = {
+    log: console.log,
+    error: console.error,
+    exit: (code) => {
+        process.exit(code);
+        throw new Error("unreachable"); // satisfies tests when mocked
+    },
+};

package/dist/sessions/level-overrides.js

@@ -0,0 +1,9 @@
+/**
+ * Apply a verbose level override to a session entry.
+ * Stub implementation for nexus compatibility.
+ */
+export function applyVerboseOverride(sessionEntry, verboseLevel) {
+    if (verboseLevel) {
+        sessionEntry.verboseLevel = verboseLevel;
+    }
+}

package/dist/sessions/send-policy.js

@@ -0,0 +1,68 @@
+export function normalizeSendPolicy(raw) {
+    const value = raw?.trim().toLowerCase();
+    if (value === "allow")
+        return "allow";
+    if (value === "deny")
+        return "deny";
+    return undefined;
+}
+function normalizeMatchValue(raw) {
+    const value = raw?.trim().toLowerCase();
+    return value ? value : undefined;
+}
+function deriveProviderFromKey(key) {
+    if (!key)
+        return undefined;
+    const parts = key.split(":").filter(Boolean);
+    if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
+        return normalizeMatchValue(parts[0]);
+    }
+    return undefined;
+}
+function deriveChatTypeFromKey(key) {
+    if (!key)
+        return undefined;
+    if (key.startsWith("group:") || key.includes(":group:"))
+        return "group";
+    if (key.includes(":channel:"))
+        return "room";
+    return undefined;
+}
+export function resolveSendPolicy(params) {
+    const override = normalizeSendPolicy(params.entry?.sendPolicy);
+    if (override)
+        return override;
+    const policy = params.cfg.session?.sendPolicy;
+    if (!policy)
+        return "allow";
+    const provider = normalizeMatchValue(params.provider) ??
+        normalizeMatchValue(params.entry?.provider) ??
+        normalizeMatchValue(params.entry?.lastProvider) ??
+        deriveProviderFromKey(params.sessionKey);
+    const chatType = normalizeMatchValue(params.chatType ?? params.entry?.chatType) ??
+        normalizeMatchValue(deriveChatTypeFromKey(params.sessionKey));
+    const sessionKey = params.sessionKey ?? "";
+    let allowedMatch = false;
+    for (const rule of policy.rules ?? []) {
+        if (!rule)
+            continue;
+        const action = normalizeSendPolicy(rule.action) ?? "allow";
+        const match = rule.match ?? {};
+        const matchProvider = normalizeMatchValue(match.provider);
+        const matchChatType = normalizeMatchValue(match.chatType);
+        const matchPrefix = normalizeMatchValue(match.keyPrefix);
+        if (matchProvider && matchProvider !== provider)
+            continue;
+        if (matchChatType && matchChatType !== chatType)
+            continue;
+        if (matchPrefix && !sessionKey.startsWith(matchPrefix))
+            continue;
+        if (action === "deny")
+            return "deny";
+        allowedMatch = true;
+    }
+    if (allowedMatch)
+        return "allow";
+    const fallback = normalizeSendPolicy(policy.default);
+    return fallback ?? "allow";
+}

package/dist/signal/client.js

@@ -0,0 +1,134 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMEOUT_MS = 10_000;
+function normalizeBaseUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        throw new Error("Signal base URL is required");
+    }
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed.replace(/\/+$/, "");
+    return `http://${trimmed}`.replace(/\/+$/, "");
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function signalRpcRequest(method, params, opts) {
+    const baseUrl = normalizeBaseUrl(opts.baseUrl);
+    const id = randomUUID();
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        params,
+        id,
+    });
+    const res = await fetchWithTimeout(`${baseUrl}/api/v1/rpc`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    if (res.status === 201) {
+        return undefined;
+    }
+    const text = await res.text();
+    if (!text) {
+        throw new Error(`Signal RPC empty response (status ${res.status})`);
+    }
+    const parsed = JSON.parse(text);
+    if (parsed.error) {
+        const code = parsed.error.code ?? "unknown";
+        const msg = parsed.error.message ?? "Signal RPC error";
+        throw new Error(`Signal RPC ${code}: ${msg}`);
+    }
+    return parsed.result;
+}
+export async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    try {
+        const res = await fetchWithTimeout(`${normalized}/api/v1/check`, { method: "GET" }, timeoutMs);
+        if (!res.ok) {
+            return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+        }
+        return { ok: true, status: res.status, error: null };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: null,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function streamSignalEvents(params) {
+    const baseUrl = normalizeBaseUrl(params.baseUrl);
+    const url = new URL(`${baseUrl}/api/v1/events`);
+    if (params.account)
+        url.searchParams.set("account", params.account);
+    const res = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "text/event-stream" },
+        signal: params.abortSignal,
+    });
+    if (!res.ok || !res.body) {
+        throw new Error(`Signal SSE failed (${res.status} ${res.statusText || "error"})`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = {};
+    const flushEvent = () => {
+        if (!currentEvent.data && !currentEvent.event && !currentEvent.id)
+            return;
+        params.onEvent({
+            event: currentEvent.event,
+            data: currentEvent.data,
+            id: currentEvent.id,
+        });
+        currentEvent = {};
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let lineEnd = buffer.indexOf("\n");
+        while (lineEnd !== -1) {
+            let line = buffer.slice(0, lineEnd);
+            buffer = buffer.slice(lineEnd + 1);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            if (line === "") {
+                flushEvent();
+                lineEnd = buffer.indexOf("\n");
+                continue;
+            }
+            if (line.startsWith(":")) {
+                lineEnd = buffer.indexOf("\n");
+                continue;
+            }
+            const [rawField, ...rest] = line.split(":");
+            const field = rawField.trim();
+            const rawValue = rest.join(":");
+            const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+            if (field === "event") {
+                currentEvent.event = value;
+            }
+            else if (field === "data") {
+                currentEvent.data = currentEvent.data
+                    ? `${currentEvent.data}\n${value}`
+                    : value;
+            }
+            else if (field === "id") {
+                currentEvent.id = value;
+            }
+            lineEnd = buffer.indexOf("\n");
+        }
+    }
+    flushEvent();
+}