@offerpilot/axiomruntime 0.0.1

package/dist/telegram/config.js

@@ -0,0 +1,235 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import { getTelegramBotConfigPath, getTelegramBotDbPath, getTelegramBotDir, getTelegramConfigPath, getTelegramDbPath } from "../core/config/paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "../core/config/json-store.js";
+import { readBoolean, readNumber, readOptionalString, readString } from "../core/config/schema.js";
+const VALID_ENGINES = new Set(["claude", "codex"]);
+const VALID_PERMISSION_MODES = new Set(["readOnly", "default", "acceptEdits", "bypassPermissions"]);
+export async function loadTelegramConfig() {
+    const raw = await readJsonFile(getTelegramConfigPath(), getDefaultTelegramConfig());
+    return normalizeTelegramConfig(raw);
+}
+export async function saveTelegramConfig(config) {
+    const normalized = normalizeTelegramConfig(config);
+    await writeJsonFile(getTelegramConfigPath(), normalized);
+    await chmodConfigFile();
+    return normalized;
+}
+export async function updateTelegramConfig(patch) {
+    const next = await updateJsonFile(getTelegramConfigPath(), getDefaultTelegramConfig(), (current) => normalizeTelegramConfig({ ...normalizeTelegramConfig(current), ...patch }));
+    await chmodConfigFile();
+    return normalizeTelegramConfig(next);
+}
+export async function setTelegramConfigValue(key, value) {
+    if (!isTelegramConfigKey(key)) {
+        throw new Error(`Unknown telegram config key: ${key}`);
+    }
+    const parsed = parseTelegramConfigValue(key, value);
+    return updateTelegramConfig({ [key]: parsed });
+}
+export function normalizeTelegramConfig(value) {
+    const defaults = getDefaultTelegramConfig();
+    const input = isConfigRecord(value) ? value : {};
+    const defaultEngine = readString(input, "defaultEngine", { fallback: defaults.defaultEngine });
+    const defaultPermissionMode = normalizePermissionMode(readString(input, "defaultPermissionMode", { fallback: defaults.defaultPermissionMode }));
+    const sessionTimeoutHours = readNumber(input, "sessionTimeoutHours", defaults.sessionTimeoutHours);
+    const maxOutputLength = readNumber(input, "maxOutputLength", defaults.maxOutputLength);
+    const allowedUserIds = normalizeAllowedUserIds(input.allowedUserIds);
+    const provider = readOptionalString(input, "provider");
+    const model = readOptionalString(input, "model");
+    const proxyUrl = readOptionalString(input, "proxyUrl");
+    const dbPath = readString(input, "dbPath", { fallback: defaults.dbPath }) || defaults.dbPath;
+    return {
+        token: readString(input, "token", { fallback: defaults.token }),
+        allowAllUsers: readBoolean(input.allowAllUsers ?? defaults.allowAllUsers),
+        allowedUserIds,
+        defaultEngine: VALID_ENGINES.has(defaultEngine) ? defaultEngine : defaults.defaultEngine,
+        defaultCwd: String(input.defaultCwd ?? defaults.defaultCwd).trim() || defaults.defaultCwd,
+        defaultPermissionMode,
+        sessionTimeoutHours: Number.isFinite(sessionTimeoutHours) && sessionTimeoutHours > 0 ? sessionTimeoutHours : defaults.sessionTimeoutHours,
+        maxOutputLength: Number.isFinite(maxOutputLength) && maxOutputLength >= 500 ? maxOutputLength : defaults.maxOutputLength,
+        ...(provider ? { provider } : {}),
+        ...(model ? { model } : {}),
+        ...(proxyUrl ? { proxyUrl } : {}),
+        dbPath
+    };
+}
+export function parseTelegramConfigValue(key, rawValue) {
+    const value = rawValue.trim();
+    if (key === "allowedUserIds") {
+        return normalizeAllowedUserIds(value);
+    }
+    if (key === "allowAllUsers") {
+        return parseBoolean(value);
+    }
+    if (key === "sessionTimeoutHours" || key === "maxOutputLength") {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new Error(`${key} must be a positive number.`);
+        }
+        return parsed;
+    }
+    if (key === "defaultEngine") {
+        if (!VALID_ENGINES.has(value)) {
+            throw new Error("defaultEngine must be claude or codex.");
+        }
+        return value;
+    }
+    if (key === "defaultPermissionMode") {
+        return normalizePermissionMode(value);
+    }
+    return value;
+}
+export function normalizePermissionMode(value) {
+    if (value === "auto-edit")
+        return "acceptEdits";
+    if (value === "full-auto")
+        return "bypassPermissions";
+    if (VALID_PERMISSION_MODES.has(value))
+        return value;
+    return getDefaultTelegramConfig().defaultPermissionMode;
+}
+export function describeTelegramConfig(config) {
+    return [
+        `token: ${config.token ? maskToken(config.token) : "(empty)"}`,
+        `allowAllUsers: ${config.allowAllUsers ? "true" : "false"}`,
+        `allowedUserIds: ${config.allowedUserIds.length ? config.allowedUserIds.join(", ") : "(empty)"}`,
+        `defaultEngine: ${config.defaultEngine}`,
+        `defaultCwd: ${config.defaultCwd}`,
+        `defaultPermissionMode: ${config.defaultPermissionMode}`,
+        `sessionTimeoutHours: ${config.sessionTimeoutHours}`,
+        `maxOutputLength: ${config.maxOutputLength}`,
+        `provider: ${config.provider ?? "(auto)"}`,
+        `model: ${config.model ?? "(auto)"}`,
+        `proxyUrl: ${config.proxyUrl ?? "(none)"}`,
+        `dbPath: ${config.dbPath}`
+    ];
+}
+function normalizeAllowedUserIds(value) {
+    const items = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? value.split(/[,\s]+/).filter(Boolean)
+            : [];
+    const seen = new Set();
+    const ids = [];
+    for (const item of items) {
+        const parsed = Number(item);
+        if (Number.isInteger(parsed) && parsed > 0 && !seen.has(parsed)) {
+            seen.add(parsed);
+            ids.push(parsed);
+        }
+    }
+    return ids;
+}
+function getDefaultTelegramConfig() {
+    return {
+        token: "",
+        allowAllUsers: false,
+        allowedUserIds: [],
+        defaultEngine: "claude",
+        defaultCwd: os.homedir(),
+        defaultPermissionMode: "bypassPermissions",
+        sessionTimeoutHours: 24,
+        maxOutputLength: 4000,
+        dbPath: getTelegramDbPath()
+    };
+}
+function isTelegramConfigKey(key) {
+    return [
+        "token",
+        "allowAllUsers",
+        "allowedUserIds",
+        "defaultEngine",
+        "defaultCwd",
+        "defaultPermissionMode",
+        "sessionTimeoutHours",
+        "maxOutputLength",
+        "provider",
+        "model",
+        "proxyUrl",
+        "dbPath"
+    ].includes(key);
+}
+function parseBoolean(value) {
+    return readBoolean(value);
+}
+function isConfigRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function chmodConfigFile() {
+    try {
+        await fs.chmod(getTelegramConfigPath(), 0o600);
+    }
+    catch {
+        // Best-effort on filesystems that may not support chmod.
+    }
+}
+function maskToken(token) {
+    if (token.length <= 12)
+        return "****";
+    return `${token.slice(0, 6)}****${token.slice(-4)}`;
+}
+export async function loadBotConfig(name) {
+    const configPath = getTelegramBotConfigPath(name);
+    const defaults = getDefaultBotConfig(name);
+    const raw = await readJsonFile(configPath, defaults);
+    return normalizeTelegramConfig(raw);
+}
+export async function saveBotConfig(name, config) {
+    const configPath = getTelegramBotConfigPath(name);
+    const dir = getTelegramBotDir();
+    await fs.mkdir(dir, { recursive: true });
+    const withDb = { ...config, dbPath: config.dbPath || getTelegramBotDbPath(name) };
+    const normalized = normalizeTelegramConfig(withDb);
+    if (normalized.dbPath === getTelegramDbPath()) {
+        normalized.dbPath = getTelegramBotDbPath(name);
+    }
+    await writeJsonFile(configPath, normalized);
+    try {
+        await fs.chmod(configPath, 0o600);
+    }
+    catch {
+        // Best-effort on filesystems that may not support chmod.
+    }
+    return normalized;
+}
+export async function updateBotConfig(name, patch) {
+    const configPath = getTelegramBotConfigPath(name);
+    const defaults = getDefaultBotConfig(name);
+    await fs.mkdir(getTelegramBotDir(), { recursive: true });
+    const next = await updateJsonFile(configPath, defaults, (current) => {
+        const normalized = normalizeTelegramConfig({ ...normalizeTelegramConfig(current), ...patch });
+        if (normalized.dbPath === getTelegramDbPath()) {
+            normalized.dbPath = getTelegramBotDbPath(name);
+        }
+        return normalized;
+    });
+    try {
+        await fs.chmod(configPath, 0o600);
+    }
+    catch {
+        // Best-effort on filesystems that may not support chmod.
+    }
+    return normalizeTelegramConfig(next);
+}
+export async function setBotConfigValue(name, key, value) {
+    if (!isTelegramConfigKey(key)) {
+        throw new Error(`Unknown telegram config key: ${key}`);
+    }
+    const parsed = parseTelegramConfigValue(key, value);
+    return updateBotConfig(name, { [key]: parsed });
+}
+function getDefaultBotConfig(name) {
+    return {
+        token: "",
+        allowAllUsers: false,
+        allowedUserIds: [],
+        defaultEngine: "claude",
+        defaultCwd: os.homedir(),
+        defaultPermissionMode: "bypassPermissions",
+        sessionTimeoutHours: 24,
+        maxOutputLength: 4000,
+        dbPath: getTelegramBotDbPath(name)
+    };
+}

package/dist/telegram/engine/claude-engine.js

@@ -0,0 +1,240 @@
+import { cleanupRuntime, createCommandPermissionRequest, formatEngineTimeout, prepareEngineRuntime, summarizeRuntime } from "./engine-utils.js";
+import { createJsonLineAccumulator, extractJsonLines, spawnCapture, stripAnsi, terminateProcessTree } from "./process-utils.js";
+import { requiresDangerousConfirmation } from "../interaction/approval.js";
+import { writeTelegramLog } from "../log.js";
+import { isRecord } from "../../core/utils/is-record.js";
+export class ClaudeEngine {
+    name = "claude";
+    processes = new Map();
+    controllers = new Map();
+    async execute(params) {
+        const permissionMode = params.permissionMode ?? "default";
+        const runtime = await prepareEngineRuntime("claude", params.providerName, params.modelName, permissionMode);
+        const controller = new AbortController();
+        this.controllers.set(params.chatId, controller);
+        const signal = params.signal ?? controller.signal;
+        const startTime = Date.now();
+        if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
+            const approved = await params.onPermission(createCommandPermissionRequest("Claude prompt", params.prompt));
+            if (!approved) {
+                cleanupRuntime(runtime);
+                throw new Error("Dangerous command denied.");
+            }
+        }
+        const args = buildClaudeArgs({
+            prompt: params.prompt,
+            model: runtime.model,
+            settingsPath: runtime.claudeSettingsPath,
+            permissionMode,
+            resume: params.resume,
+            allowedTools: params.allowedTools
+        });
+        await params.onProgress?.({ phase: "thinking", message: "Claude started" });
+        await writeTelegramLog({
+            action: "claude_start",
+            message: `Starting Claude for Telegram chat ${params.chatId}`,
+            metadata: { ...summarizeRuntime(runtime.provider, runtime.model, "claude"), cwd: params.cwd }
+        });
+        try {
+            const progressParser = createJsonLineAccumulator((event) => handleClaudeProgressEvent(event, params.onProgress));
+            const result = await spawnCapture({
+                command: runtime.command,
+                args,
+                cwd: params.cwd,
+                env: {
+                    ...runtime.env,
+                    CLAUDE_CODE_HEADLESS: "1"
+                },
+                signal,
+                timeoutMs: params.timeoutMs,
+                onStdout: (chunk) => progressParser.push(chunk)
+            }, (child) => this.processes.set(params.chatId, child));
+            progressParser.end();
+            if (result.timedOut) {
+                throw new Error(formatEngineTimeout("Claude Code", params.timeoutMs, runtime.provider.name, runtime.model));
+            }
+            if (result.aborted) {
+                throw new Error("任务已停止。");
+            }
+            if (result.code !== 0) {
+                throw new Error(formatClaudeFailure(result.stdout, result.stderr, result.code));
+            }
+            const parsed = parseClaudeOutput(result.stdout, Date.now() - startTime);
+            await params.onProgress?.({ phase: "done" });
+            return {
+                ...parsed,
+                provider: runtime.provider.name,
+                model: runtime.model
+            };
+        }
+        finally {
+            this.processes.delete(params.chatId);
+            this.controllers.delete(params.chatId);
+            cleanupRuntime(runtime);
+        }
+    }
+    abort(chatId) {
+        if (!Number.isFinite(chatId)) {
+            for (const id of new Set([...this.controllers.keys(), ...this.processes.keys()])) {
+                this.abort(id);
+            }
+            return;
+        }
+        this.controllers.get(chatId)?.abort();
+        const child = this.processes.get(chatId);
+        if (child)
+            terminateProcessTree(child, "SIGTERM");
+        this.controllers.delete(chatId);
+        this.processes.delete(chatId);
+    }
+}
+export function buildClaudeArgs(options) {
+    const permissionMode = options.permissionMode === "readOnly" ? "default" : options.permissionMode;
+    const args = [
+        "-p",
+        options.prompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--model",
+        options.model,
+        "--settings",
+        options.settingsPath ?? "",
+        "--permission-mode",
+        permissionMode,
+        "--max-budget-usd",
+        "20"
+    ].filter(Boolean);
+    if (options.resume) {
+        args.push("--resume", options.resume);
+    }
+    if (options.allowedTools?.length) {
+        args.push("--allowedTools", options.allowedTools.join(","));
+    }
+    if (options.permissionMode === "bypassPermissions") {
+        args.push("--dangerously-skip-permissions");
+    }
+    if (options.permissionMode === "readOnly") {
+        args.push("--allowedTools", "Read,Grep,Glob,WebFetch,WebSearch");
+    }
+    return args;
+}
+export function parseClaudeOutput(raw, duration) {
+    const events = extractJsonLines(raw);
+    let response = "";
+    let sessionId;
+    let cost;
+    const toolCalls = [];
+    for (const event of events) {
+        if (!isRecord(event))
+            continue;
+        if (typeof event.session_id === "string")
+            sessionId = event.session_id;
+        if (typeof event.sessionId === "string")
+            sessionId = event.sessionId;
+        if (typeof event.total_cost_usd === "number")
+            cost = event.total_cost_usd;
+        if (typeof event.cost_usd === "number")
+            cost = event.cost_usd;
+        if (event.type === "result" && typeof event.result === "string") {
+            response = event.result;
+        }
+        collectTextFromMessage(event, (text) => {
+            if (!response.includes(text))
+                response += `${response ? "\n" : ""}${text}`;
+        });
+        collectToolCalls(event, toolCalls);
+    }
+    if (!response.trim()) {
+        response = stripAnsi(raw).trim();
+    }
+    return {
+        sessionId,
+        response,
+        toolCalls,
+        filesChanged: extractFilesChanged(toolCalls),
+        cost,
+        duration
+    };
+}
+export function formatClaudeFailure(stdout, stderr = "", code) {
+    let terminalResult = "";
+    for (const event of extractJsonLines(stdout)) {
+        if (!isRecord(event) || event.type !== "result")
+            continue;
+        if (typeof event.result === "string" && event.result.trim()) {
+            terminalResult = event.result.trim();
+        }
+    }
+    const stderrText = stripAnsi(stderr).trim();
+    const plainStdout = stripAnsi(stdout)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("{"))
+        .slice(-6)
+        .join("\n");
+    const diagnostics = [stderrText, terminalResult, plainStdout]
+        .filter((value, index, values) => value && values.indexOf(value) === index);
+    return diagnostics.join("\n") || `Claude exited with code ${code ?? "unknown"}.`;
+}
+function handleClaudeProgressEvent(event, onProgress) {
+    if (!onProgress)
+        return;
+    if (!isRecord(event) || event.type !== "assistant")
+        return;
+    const tool = findFirstToolName(event);
+    if (tool) {
+        void onProgress({ phase: "tool_calling", tool });
+    }
+    else {
+        const responseText = readMessageText(event);
+        void onProgress({ phase: "writing", responseText: responseText || undefined });
+    }
+}
+function readMessageText(event) {
+    const parts = [];
+    collectTextFromMessage(event, (text) => {
+        if (text.trim())
+            parts.push(text.trim());
+    });
+    return parts.join("\n");
+}
+function collectTextFromMessage(event, add) {
+    const message = isRecord(event.message) ? event.message : event;
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const item of content) {
+        if (isRecord(item) && item.type === "text" && typeof item.text === "string") {
+            add(item.text);
+        }
+    }
+}
+function collectToolCalls(event, calls) {
+    const message = isRecord(event.message) ? event.message : event;
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const item of content) {
+        if (isRecord(item) && item.type === "tool_use") {
+            calls.push({
+                tool: String(item.name ?? "tool"),
+                input: isRecord(item.input) ? item.input : {},
+                output: "",
+                status: "success"
+            });
+        }
+    }
+}
+function findFirstToolName(event) {
+    const message = isRecord(event.message) ? event.message : event;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const tool = content.find((item) => isRecord(item) && item.type === "tool_use");
+    return isRecord(tool) ? String(tool.name ?? "") || undefined : undefined;
+}
+function extractFilesChanged(calls) {
+    const files = new Set();
+    for (const call of calls) {
+        const filePath = call.input.file_path ?? call.input.path;
+        if (typeof filePath === "string" && ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(call.tool)) {
+            files.add(filePath);
+        }
+    }
+    return [...files];
+}