mono-pilot 0.2.10 → 0.2.13

package/dist/src/cluster_v2/services/twitter/index.js

@@ -0,0 +1 @@
+export { maybeStartTwitterCollector } from "./collector.js";

package/dist/src/config/digest.js

@@ -0,0 +1,78 @@
+const DEFAULT_TEMPERATURE = 0;
+const DEFAULT_MAX_TOKENS = 300;
+const DEFAULT_CONCURRENCY = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeNumber(value, fallback, { integer, min, max, } = {}) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    let next = integer ? Math.floor(value) : value;
+    if (typeof min === "number") {
+        next = Math.max(min, next);
+    }
+    if (typeof max === "number") {
+        next = Math.min(max, next);
+    }
+    return next;
+}
+function readClassifierRecord(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return isRecord(value.classifier) ? value.classifier : {};
+}
+function readTwitterDigestClassifier(config) {
+    if (!isRecord(config.twitter)) {
+        return {};
+    }
+    const twitter = config.twitter;
+    return readClassifierRecord(twitter.digest);
+}
+function readLegacyDigestClassifier(config) {
+    return readClassifierRecord(config.digest);
+}
+export function extractDigestConfig(config) {
+    if (!config) {
+        return {
+            classifier: {
+                provider: undefined,
+                model: undefined,
+                temperature: DEFAULT_TEMPERATURE,
+                maxTokens: DEFAULT_MAX_TOKENS,
+                concurrency: DEFAULT_CONCURRENCY,
+            },
+        };
+    }
+    const twitterClassifier = readTwitterDigestClassifier(config);
+    const legacyClassifier = readLegacyDigestClassifier(config);
+    const provider = readString(twitterClassifier.provider) ?? readString(legacyClassifier.provider);
+    const model = readString(twitterClassifier.model) ?? readString(legacyClassifier.model);
+    const temperatureRaw = twitterClassifier.temperature ?? legacyClassifier.temperature;
+    const maxTokensRaw = twitterClassifier.maxTokens ?? legacyClassifier.maxTokens;
+    const concurrencyRaw = twitterClassifier.concurrency ?? legacyClassifier.concurrency;
+    return {
+        classifier: {
+            provider,
+            model,
+            temperature: normalizeNumber(temperatureRaw, DEFAULT_TEMPERATURE, { min: 0, max: 2 }),
+            maxTokens: normalizeNumber(maxTokensRaw, DEFAULT_MAX_TOKENS, {
+                integer: true,
+                min: 1,
+            }),
+            concurrency: normalizeNumber(concurrencyRaw, DEFAULT_CONCURRENCY, {
+                integer: true,
+                min: 1,
+                max: 16,
+            }),
+        },
+    };
+}

package/dist/src/config/discord.js

@@ -0,0 +1,143 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+export const DISCORD_SUBSCRIBE_EVENTS = [
+    "MESSAGE_CREATE",
+    "MESSAGE_UPDATE",
+    "MESSAGE_DELETE",
+];
+const DEFAULT_OUTPUT_PATH = join(homedir(), ".mono-pilot", "discord", "messages.jsonl");
+const DEFAULT_RECONNECT_DELAY_MS = 30_000;
+const DEFAULT_SYSTEM_EVENT_BATCH_SIZE = 20;
+const DEFAULT_SCOPES = ["rpc", "messages.read", "identify"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readStringArray(value) {
+    if (typeof value === "string") {
+        const values = value
+            .split(/\s+/)
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        return [...new Set(values)];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const values = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return [...new Set(values)];
+}
+function normalizeChannels(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const seen = new Set();
+    const channels = [];
+    for (const item of value) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const id = readString(item.id);
+        if (!id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        const alias = readString(item.alias);
+        channels.push(alias ? { id, alias } : { id });
+    }
+    return channels;
+}
+function normalizeScopes(value) {
+    const scopes = readStringArray(value);
+    if (scopes.length > 0) {
+        return scopes;
+    }
+    return [...DEFAULT_SCOPES];
+}
+function normalizeOutputPath(rawPath) {
+    if (!rawPath) {
+        return DEFAULT_OUTPUT_PATH;
+    }
+    let expanded = rawPath;
+    if (expanded === "~") {
+        expanded = homedir();
+    }
+    else if (expanded.startsWith("~/")) {
+        expanded = join(homedir(), expanded.slice(2));
+    }
+    if (isAbsolute(expanded)) {
+        return expanded;
+    }
+    return resolve(expanded);
+}
+function normalizeEvents(value) {
+    const allowed = new Set(DISCORD_SUBSCRIBE_EVENTS);
+    const list = readStringArray(value)
+        .map((item) => item.toUpperCase())
+        .filter((item) => allowed.has(item));
+    if (list.length === 0) {
+        return ["MESSAGE_CREATE"];
+    }
+    return [...new Set(list)];
+}
+function normalizeReconnectDelay(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_RECONNECT_DELAY_MS;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return DEFAULT_RECONNECT_DELAY_MS;
+    }
+    return normalized;
+}
+function normalizeSystemEventBatchSize(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_SYSTEM_EVENT_BATCH_SIZE;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return DEFAULT_SYSTEM_EVENT_BATCH_SIZE;
+    }
+    return normalized;
+}
+export function extractDiscordCollectorConfig(config) {
+    if (!config || !isRecord(config.discord)) {
+        return {
+            enabled: false,
+            scopes: [...DEFAULT_SCOPES],
+            channels: [],
+            events: ["MESSAGE_CREATE"],
+            outputPath: DEFAULT_OUTPUT_PATH,
+            includeRawPayload: false,
+            maxReconnectDelayMs: DEFAULT_RECONNECT_DELAY_MS,
+            systemEventBatchSize: DEFAULT_SYSTEM_EVENT_BATCH_SIZE,
+        };
+    }
+    const discord = config.discord;
+    const channels = normalizeChannels(discord.channels);
+    const fallbackChannelIds = readStringArray(discord.channelIds);
+    const normalizedChannels = channels.length > 0 ? channels : fallbackChannelIds.map((id) => ({ id }));
+    return {
+        enabled: discord.enabled === true,
+        clientId: readString(discord.clientId),
+        accessToken: readString(discord.accessToken),
+        clientSecret: readString(discord.clientSecret),
+        redirectUri: readString(discord.redirectUri),
+        scopes: normalizeScopes(discord.scopes),
+        channels: normalizedChannels,
+        events: normalizeEvents(discord.events),
+        outputPath: normalizeOutputPath(readString(discord.outputPath)),
+        includeRawPayload: discord.includeRawPayload === true,
+        maxReconnectDelayMs: normalizeReconnectDelay(discord.maxReconnectDelayMs),
+        systemEventBatchSize: normalizeSystemEventBatchSize(discord.systemEventBatchSize),
+    };
+}

package/dist/src/config/image-gen.js

@@ -0,0 +1,48 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function extractImageGenConfig(config) {
+    const providers = {};
+    const selection = {};
+    if (!config) {
+        return { providers, selection };
+    }
+    if (isRecord(config.imageGen)) {
+        selection.provider = readString(config.imageGen.provider);
+        selection.model = readString(config.imageGen.model);
+    }
+    if (isRecord(config.imageGenProviders)) {
+        for (const [key, value] of Object.entries(config.imageGenProviders)) {
+            if (!isRecord(value))
+                continue;
+            const modelsRaw = Array.isArray(value.models) ? value.models : [];
+            const models = modelsRaw
+                .map((entry) => {
+                if (!isRecord(entry))
+                    return undefined;
+                const id = readString(entry.id);
+                if (!id)
+                    return undefined;
+                const name = readString(entry.name);
+                return name ? { id, name } : { id };
+            })
+                .filter((entry) => Boolean(entry));
+            providers[key] = {
+                baseUrl: readString(value.baseUrl),
+                apiKey: readString(value.apiKey),
+                authHeader: typeof value.authHeader === "boolean" ? value.authHeader : undefined,
+                models: models.length > 0 ? models : undefined,
+            };
+        }
+    }
+    return { providers, selection };
+}
+export function applyImageGenSelection(config, selection) {
+    config.imageGen = {
+        provider: selection.provider,
+        model: selection.model,
+    };
+}

package/dist/src/config/mono-pilot.js

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { getUserConfigDir, getUserConfigPath } from "../memory/config/paths.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export async function loadMonoPilotConfigObject() {
+    const configPath = getUserConfigPath();
+    if (!existsSync(configPath))
+        return {};
+    const raw = await readFile(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON in mono-pilot config: ${message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new Error("MonoPilot config root must be a JSON object.");
+    }
+    return parsed;
+}
+export async function saveMonoPilotConfigObject(config) {
+    const configDir = getUserConfigDir();
+    await mkdir(configDir, { recursive: true });
+    const configPath = getUserConfigPath();
+    const payload = JSON.stringify(config, null, 2);
+    await writeFile(configPath, `${payload}\n`, "utf-8");
+}

package/dist/src/config/twitter.js

@@ -0,0 +1,100 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+const DEFAULT_OUTPUT_PATH = join(homedir(), ".mono-pilot", "twitter", "home.jsonl");
+const DEFAULT_PULL_INTERVAL_MINUTES = 10;
+const DEFAULT_PULL_COUNT = 10;
+const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readStringArray(value) {
+    if (typeof value === "string") {
+        const values = value
+            .split(/\s+/)
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        return [...new Set(values)];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const values = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return [...new Set(values)];
+}
+function normalizeOutputPath(rawPath) {
+    if (!rawPath) {
+        return DEFAULT_OUTPUT_PATH;
+    }
+    let expanded = rawPath;
+    if (expanded === "~") {
+        expanded = homedir();
+    }
+    else if (expanded.startsWith("~/")) {
+        expanded = join(homedir(), expanded.slice(2));
+    }
+    if (isAbsolute(expanded)) {
+        return expanded;
+    }
+    return resolve(expanded);
+}
+function normalizePositiveInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return fallback;
+    }
+    return normalized;
+}
+function normalizeOptionalPositiveInteger(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return undefined;
+    }
+    return normalized;
+}
+export function extractTwitterCollectorConfig(config) {
+    if (!config || !isRecord(config.twitter)) {
+        return {
+            enabled: false,
+            outputPath: DEFAULT_OUTPUT_PATH,
+            pullIntervalMinutes: DEFAULT_PULL_INTERVAL_MINUTES,
+            pullCount: DEFAULT_PULL_COUNT,
+            includeRawPayload: false,
+            commandTimeoutMs: DEFAULT_COMMAND_TIMEOUT_MS,
+            cookieSource: [],
+        };
+    }
+    const twitter = config.twitter;
+    return {
+        enabled: twitter.enabled === true,
+        outputPath: normalizeOutputPath(readString(twitter.outputPath)),
+        pullIntervalMinutes: normalizePositiveInteger(twitter.pullIntervalMinutes, DEFAULT_PULL_INTERVAL_MINUTES),
+        pullCount: normalizePositiveInteger(twitter.pullCount, DEFAULT_PULL_COUNT),
+        includeRawPayload: twitter.includeRawPayload === true,
+        commandTimeoutMs: normalizePositiveInteger(twitter.commandTimeoutMs, DEFAULT_COMMAND_TIMEOUT_MS),
+        requestTimeoutMs: normalizeOptionalPositiveInteger(twitter.requestTimeoutMs),
+        chromeProfile: readString(twitter.chromeProfile),
+        chromeProfileDir: readString(twitter.chromeProfileDir),
+        firefoxProfile: readString(twitter.firefoxProfile),
+        cookieSource: readStringArray(twitter.cookieSource),
+        cookieTimeoutMs: normalizeOptionalPositiveInteger(twitter.cookieTimeoutMs),
+    };
+}