tickflow-assist 0.2.0

package/dist/dev/tickflow-assist-cli.js

@@ -0,0 +1,525 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import JSON5 from "json5";
+const PLUGIN_ID = "tickflow-assist";
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
+const DEFAULTS = {
+    tickflowApiUrl: "https://api.tickflow.org",
+    tickflowApiKeyLevel: "Free",
+    mxSearchApiUrl: "https://mkapi2.dfcfs.com/finskillshub/api/claw",
+    mxSearchApiKey: "",
+    llmBaseUrl: "https://api.openai.com/v1",
+    llmModel: "gpt-4o",
+    requestInterval: 30,
+    dailyUpdateNotify: true,
+    alertChannel: "telegram",
+    openclawCliBin: "openclaw",
+    alertAccount: "",
+    pythonBin: "uv",
+    pythonArgs: ["run", "python"],
+};
+function printUsage() {
+    console.log(`TickFlow Assist CLI
+
+Usage:
+  tickflow-assist configure-openclaw [options]
+
+Options:
+  --config-path <path>         Override OpenClaw config path
+  --plugin-dir <path>          Override installed plugin directory
+  --agent <id>                Apply tools.allow to a specific agent
+  --global                    Apply tools.allow to top-level tools config
+  --non-interactive           Use existing config / flags only, no prompts
+  --no-enable                 Do not run 'openclaw plugins enable'
+  --no-restart                Do not run 'openclaw gateway restart'
+  --openclaw-bin <path>       OpenClaw CLI binary, default: openclaw
+  --tickflow-api-key <key>
+  --tickflow-api-key-level <Free|Start|Pro|Expert>
+  --mx-search-api-key <key>
+  --llm-base-url <url>
+  --llm-api-key <key>
+  --llm-model <name>
+  --alert-channel <name>
+  --alert-account <name>
+  --alert-target <target>
+  -h, --help                  Show this help
+`);
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    let command = "help";
+    const options = {
+        command,
+        globalTarget: false,
+        nonInteractive: false,
+        restart: true,
+        enable: true,
+        openclawBin: DEFAULTS.openclawCliBin,
+        overrides: {},
+    };
+    const first = args[0];
+    if (first && !first.startsWith("-")) {
+        if (first === "configure-openclaw") {
+            command = "configure-openclaw";
+            args.shift();
+        }
+        else if (first === "help") {
+            command = "help";
+            args.shift();
+        }
+    }
+    else {
+        command = "configure-openclaw";
+    }
+    options.command = command;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        const next = args[index + 1];
+        const requireValue = (flag) => {
+            if (!next || next.startsWith("-")) {
+                throw new Error(`${flag} requires a value`);
+            }
+            index += 1;
+            return next;
+        };
+        switch (token) {
+            case "-h":
+            case "--help":
+                options.command = "help";
+                break;
+            case "--config-path":
+                options.configPath = requireValue(token);
+                break;
+            case "--plugin-dir":
+                options.pluginDir = requireValue(token);
+                break;
+            case "--agent":
+                options.agentId = requireValue(token);
+                break;
+            case "--global":
+                options.globalTarget = true;
+                break;
+            case "--non-interactive":
+                options.nonInteractive = true;
+                break;
+            case "--no-restart":
+                options.restart = false;
+                break;
+            case "--no-enable":
+                options.enable = false;
+                break;
+            case "--openclaw-bin":
+                options.openclawBin = requireValue(token);
+                break;
+            case "--tickflow-api-key":
+                options.overrides.tickflowApiKey = requireValue(token);
+                break;
+            case "--tickflow-api-key-level":
+                options.overrides.tickflowApiKeyLevel = normalizeApiKeyLevel(requireValue(token));
+                break;
+            case "--mx-search-api-key":
+                options.overrides.mxSearchApiKey = requireValue(token);
+                break;
+            case "--llm-base-url":
+                options.overrides.llmBaseUrl = requireValue(token);
+                break;
+            case "--llm-api-key":
+                options.overrides.llmApiKey = requireValue(token);
+                break;
+            case "--llm-model":
+                options.overrides.llmModel = requireValue(token);
+                break;
+            case "--alert-channel":
+                options.overrides.alertChannel = requireValue(token);
+                break;
+            case "--alert-account":
+                options.overrides.alertAccount = requireValue(token);
+                break;
+            case "--alert-target":
+                options.overrides.alertTarget = requireValue(token);
+                break;
+            default:
+                throw new Error(`unknown argument: ${token}`);
+        }
+    }
+    return options;
+}
+function normalizeApiKeyLevel(value) {
+    const normalized = value.trim().toLowerCase();
+    switch (normalized) {
+        case "free":
+            return "Free";
+        case "start":
+            return "Start";
+        case "pro":
+            return "Pro";
+        case "expert":
+            return "Expert";
+        default:
+            throw new Error(`invalid tickflowApiKeyLevel: ${value}`);
+    }
+}
+function resolveOpenClawConfigPath(input) {
+    return input || process.env.OPENCLAW_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+}
+function resolveStateDir(configPath) {
+    return process.env.OPENCLAW_STATE_DIR || process.env.OPENCLAW_HOME || path.dirname(configPath);
+}
+async function readConfigFile(configPath) {
+    try {
+        const raw = await readFile(configPath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (typeof parsed === "object" && parsed !== null) {
+            return parsed;
+        }
+        throw new Error("OpenClaw config must be an object");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+function getObject(parent, key) {
+    const current = parent[key];
+    if (typeof current === "object" && current !== null && !Array.isArray(current)) {
+        return current;
+    }
+    const created = {};
+    parent[key] = created;
+    return created;
+}
+function getArray(parent, key) {
+    const current = parent[key];
+    if (Array.isArray(current)) {
+        return current;
+    }
+    const created = [];
+    parent[key] = created;
+    return created;
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.trim()))];
+}
+function mergeAllowlist(target, pluginId) {
+    const allow = Array.isArray(target.allow)
+        ? target.allow.map((value) => String(value))
+        : [];
+    target.allow = uniqueStrings([...allow, pluginId]);
+}
+function getExistingPluginConfig(root) {
+    const plugins = typeof root.plugins === "object" && root.plugins !== null
+        ? root.plugins
+        : {};
+    const entries = typeof plugins.entries === "object" && plugins.entries !== null
+        ? plugins.entries
+        : {};
+    const entry = typeof entries[PLUGIN_ID] === "object" && entries[PLUGIN_ID] !== null
+        ? entries[PLUGIN_ID]
+        : {};
+    const config = typeof entry.config === "object" && entry.config !== null
+        ? entry.config
+        : {};
+    const pythonArgs = Array.isArray(config.pythonArgs)
+        ? config.pythonArgs.map((value) => String(value))
+        : undefined;
+    const requestInterval = Number(config.requestInterval ?? DEFAULTS.requestInterval);
+    const dailyUpdateNotify = typeof config.dailyUpdateNotify === "boolean"
+        ? config.dailyUpdateNotify
+        : DEFAULTS.dailyUpdateNotify;
+    return {
+        tickflowApiUrl: stringValue(config.tickflowApiUrl, DEFAULTS.tickflowApiUrl),
+        tickflowApiKey: stringValue(config.tickflowApiKey),
+        tickflowApiKeyLevel: normalizeApiKeyLevel(stringValue(config.tickflowApiKeyLevel, DEFAULTS.tickflowApiKeyLevel)),
+        mxSearchApiUrl: stringValue(config.mxSearchApiUrl, DEFAULTS.mxSearchApiUrl),
+        mxSearchApiKey: stringValue(config.mxSearchApiKey, DEFAULTS.mxSearchApiKey),
+        llmBaseUrl: stringValue(config.llmBaseUrl, DEFAULTS.llmBaseUrl),
+        llmApiKey: stringValue(config.llmApiKey),
+        llmModel: stringValue(config.llmModel, DEFAULTS.llmModel),
+        requestInterval: Number.isFinite(requestInterval) ? Math.max(5, Math.trunc(requestInterval)) : DEFAULTS.requestInterval,
+        dailyUpdateNotify,
+        alertChannel: stringValue(config.alertChannel, DEFAULTS.alertChannel),
+        openclawCliBin: stringValue(config.openclawCliBin, DEFAULTS.openclawCliBin),
+        alertAccount: stringValue(config.alertAccount, DEFAULTS.alertAccount),
+        alertTarget: stringValue(config.alertTarget),
+        pythonBin: stringValue(config.pythonBin, DEFAULTS.pythonBin),
+        pythonArgs: pythonArgs && pythonArgs.length > 0 ? pythonArgs : [...DEFAULTS.pythonArgs],
+        pythonWorkdir: stringValue(config.pythonWorkdir),
+        databasePath: stringValue(config.databasePath),
+        calendarFile: stringValue(config.calendarFile),
+    };
+}
+function stringValue(value, fallback = "") {
+    return typeof value === "string" ? value.trim() : fallback;
+}
+function inferAllowTarget(root, options) {
+    if (options.globalTarget) {
+        return { type: "global" };
+    }
+    if (options.agentId) {
+        return { type: "agent", id: options.agentId };
+    }
+    const agents = typeof root.agents === "object" && root.agents !== null
+        ? root.agents
+        : null;
+    const list = Array.isArray(agents?.list) ? agents.list : [];
+    const ids = list
+        .filter((entry) => typeof entry === "object" && entry !== null)
+        .map((entry) => stringValue(entry.id))
+        .filter(Boolean);
+    if (ids.includes("stock")) {
+        return { type: "agent", id: "stock" };
+    }
+    if (ids.length === 1) {
+        return { type: "agent", id: ids[0] };
+    }
+    return { type: "global" };
+}
+async function promptForConfig(options, existing, pluginDir) {
+    const defaults = {
+        tickflowApiUrl: DEFAULTS.tickflowApiUrl,
+        tickflowApiKey: "",
+        tickflowApiKeyLevel: DEFAULTS.tickflowApiKeyLevel,
+        mxSearchApiUrl: DEFAULTS.mxSearchApiUrl,
+        mxSearchApiKey: DEFAULTS.mxSearchApiKey,
+        llmBaseUrl: DEFAULTS.llmBaseUrl,
+        llmApiKey: "",
+        llmModel: DEFAULTS.llmModel,
+        requestInterval: DEFAULTS.requestInterval,
+        dailyUpdateNotify: DEFAULTS.dailyUpdateNotify,
+        alertChannel: DEFAULTS.alertChannel,
+        openclawCliBin: options.openclawBin || DEFAULTS.openclawCliBin,
+        alertAccount: DEFAULTS.alertAccount,
+        alertTarget: "",
+        pythonBin: DEFAULTS.pythonBin,
+        pythonArgs: [...DEFAULTS.pythonArgs],
+        pythonWorkdir: path.join(pluginDir, "python"),
+        databasePath: path.join(pluginDir, "data", "lancedb"),
+        calendarFile: path.join(pluginDir, "day_future.txt"),
+    };
+    const seed = {
+        ...defaults,
+        ...existing,
+        ...options.overrides,
+        openclawCliBin: options.openclawBin || existing.openclawCliBin || DEFAULTS.openclawCliBin,
+        pythonWorkdir: path.join(pluginDir, "python"),
+        databasePath: path.join(pluginDir, "data", "lancedb"),
+        calendarFile: path.join(pluginDir, "day_future.txt"),
+    };
+    if (options.nonInteractive) {
+        assertRequired(seed);
+        return seed;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("TickFlow Assist 社区安装配置向导");
+        console.log(`OpenClaw 配置文件: ${resolveOpenClawConfigPath(options.configPath)}`);
+        console.log(`插件目录: ${pluginDir}`);
+        console.log("");
+        seed.tickflowApiKey = await promptString(rl, "TickFlow API Key", seed.tickflowApiKey, true);
+        seed.tickflowApiKeyLevel = normalizeApiKeyLevel(await promptString(rl, "TickFlow API Key Level [Free/Start/Pro/Expert]", seed.tickflowApiKeyLevel, true));
+        seed.mxSearchApiKey = await promptString(rl, "MX Search API Key (可留空)", seed.mxSearchApiKey, false);
+        seed.llmBaseUrl = await promptString(rl, "LLM Base URL", seed.llmBaseUrl, true);
+        seed.llmApiKey = await promptString(rl, "LLM API Key", seed.llmApiKey, true);
+        seed.llmModel = await promptString(rl, "LLM Model", seed.llmModel, true);
+        seed.alertChannel = await promptString(rl, "Alert Channel", seed.alertChannel, true);
+        seed.alertAccount = await promptString(rl, "Alert Account (可留空)", seed.alertAccount, false);
+        seed.alertTarget = await promptString(rl, "Alert Target", seed.alertTarget, true);
+        seed.requestInterval = await promptInteger(rl, "Request Interval (seconds)", seed.requestInterval, 5);
+        seed.dailyUpdateNotify = await promptBoolean(rl, "Daily Update Notify", seed.dailyUpdateNotify);
+    }
+    finally {
+        rl.close();
+    }
+    assertRequired(seed);
+    return seed;
+}
+async function promptString(rl, label, defaultValue, required) {
+    while (true) {
+        const suffix = defaultValue ? ` [${defaultValue}]` : "";
+        const answer = (await rl.question(`${label}${suffix}: `)).trim();
+        const value = answer || defaultValue;
+        if (!required || value) {
+            return value;
+        }
+        console.error(`${label} 不能为空`);
+    }
+}
+async function promptInteger(rl, label, defaultValue, minimum) {
+    while (true) {
+        const answer = (await rl.question(`${label} [${defaultValue}]: `)).trim();
+        const value = answer ? Number(answer) : defaultValue;
+        if (Number.isFinite(value) && value >= minimum) {
+            return Math.trunc(value);
+        }
+        console.error(`${label} 必须是 >= ${minimum} 的整数`);
+    }
+}
+async function promptBoolean(rl, label, defaultValue) {
+    while (true) {
+        const answer = (await rl.question(`${label} [${defaultValue ? "Y/n" : "y/N"}]: `)).trim().toLowerCase();
+        if (!answer) {
+            return defaultValue;
+        }
+        if (["y", "yes", "1", "true"].includes(answer)) {
+            return true;
+        }
+        if (["n", "no", "0", "false"].includes(answer)) {
+            return false;
+        }
+        console.error(`${label} 请输入 y 或 n`);
+    }
+}
+function assertRequired(config) {
+    if (!config.tickflowApiKey) {
+        throw new Error("tickflowApiKey is required");
+    }
+    if (!config.llmApiKey) {
+        throw new Error("llmApiKey is required");
+    }
+    if (!config.alertTarget) {
+        throw new Error("alertTarget is required");
+    }
+}
+async function ensurePathNotice(targetPath, label) {
+    try {
+        await access(targetPath);
+    }
+    catch {
+        console.warn(`Warning: ${label} not found at ${targetPath}`);
+    }
+}
+function applyPluginConfig(root, config, target) {
+    const plugins = getObject(root, "plugins");
+    plugins.enabled = true;
+    const entries = getObject(plugins, "entries");
+    const pluginEntry = getObject(entries, PLUGIN_ID);
+    pluginEntry.enabled = true;
+    pluginEntry.config = {
+        tickflowApiUrl: config.tickflowApiUrl,
+        tickflowApiKey: config.tickflowApiKey,
+        tickflowApiKeyLevel: config.tickflowApiKeyLevel,
+        mxSearchApiUrl: config.mxSearchApiUrl,
+        mxSearchApiKey: config.mxSearchApiKey,
+        llmBaseUrl: config.llmBaseUrl,
+        llmApiKey: config.llmApiKey,
+        llmModel: config.llmModel,
+        databasePath: config.databasePath,
+        calendarFile: config.calendarFile,
+        requestInterval: config.requestInterval,
+        dailyUpdateNotify: config.dailyUpdateNotify,
+        alertChannel: config.alertChannel,
+        openclawCliBin: config.openclawCliBin,
+        alertAccount: config.alertAccount,
+        alertTarget: config.alertTarget,
+        pythonBin: config.pythonBin,
+        pythonArgs: config.pythonArgs,
+        pythonWorkdir: config.pythonWorkdir,
+    };
+    const pluginAllow = Array.isArray(plugins.allow)
+        ? plugins.allow.map((value) => String(value))
+        : [];
+    plugins.allow = uniqueStrings([...pluginAllow, PLUGIN_ID]);
+    if (target.type === "global") {
+        const tools = getObject(root, "tools");
+        mergeAllowlist(tools, PLUGIN_ID);
+        return;
+    }
+    const agents = getObject(root, "agents");
+    const list = getArray(agents, "list");
+    let matched = false;
+    for (const item of list) {
+        if (typeof item !== "object" || item === null) {
+            continue;
+        }
+        const entry = item;
+        if (stringValue(entry.id) !== target.id) {
+            continue;
+        }
+        const tools = getObject(entry, "tools");
+        mergeAllowlist(tools, PLUGIN_ID);
+        matched = true;
+    }
+    if (!matched) {
+        list.push({
+            id: target.id,
+            tools: {
+                allow: [PLUGIN_ID],
+            },
+        });
+    }
+}
+async function writeConfig(configPath, root) {
+    await mkdir(path.dirname(configPath), { recursive: true });
+    let backupPath = null;
+    try {
+        const existing = await readFile(configPath, "utf-8");
+        backupPath = `${configPath}.backup.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+        await writeFile(backupPath, existing, "utf-8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    await writeFile(configPath, `${JSON.stringify(root, null, 2)}\n`, "utf-8");
+    return backupPath;
+}
+function runOpenClaw(bin, args, description) {
+    const result = spawnSync(bin, args, { stdio: "inherit" });
+    if (result.error) {
+        console.warn(`Warning: failed to run ${description}: ${result.error.message}`);
+        return;
+    }
+    if (result.status !== 0) {
+        console.warn(`Warning: ${description} exited with status ${result.status}`);
+    }
+}
+async function configureOpenClaw(options) {
+    const configPath = resolveOpenClawConfigPath(options.configPath);
+    const stateDir = resolveStateDir(configPath);
+    const pluginDir = path.resolve(options.pluginDir || path.join(stateDir, "extensions", PLUGIN_ID));
+    const root = await readConfigFile(configPath);
+    const target = inferAllowTarget(root, options);
+    const existing = getExistingPluginConfig(root);
+    const config = await promptForConfig(options, existing, pluginDir);
+    await ensurePathNotice(config.calendarFile, "calendarFile");
+    await ensurePathNotice(config.pythonWorkdir, "pythonWorkdir");
+    applyPluginConfig(root, config, target);
+    const backupPath = await writeConfig(configPath, root);
+    console.log("");
+    console.log(`Updated OpenClaw config: ${configPath}`);
+    if (backupPath) {
+        console.log(`Backup created: ${backupPath}`);
+    }
+    console.log(`Plugin dir: ${pluginDir}`);
+    console.log(`Allowlist target: ${target.type === "global" ? "global tools" : `agent:${target.id}`}`);
+    if (options.enable) {
+        runOpenClaw(options.openclawBin, ["plugins", "enable", PLUGIN_ID], "openclaw plugins enable");
+    }
+    runOpenClaw(options.openclawBin, ["config", "validate"], "openclaw config validate");
+    if (options.restart) {
+        runOpenClaw(options.openclawBin, ["gateway", "restart"], "openclaw gateway restart");
+    }
+}
+async function main() {
+    try {
+        const options = parseArgs(process.argv.slice(2));
+        if (options.command === "help") {
+            printUsage();
+            return;
+        }
+        await configureOpenClaw(options);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/dev/validate-mx-search.d.ts

@@ -0,0 +1 @@
+export {};