@agentbean/daemon 0.1.35 → 0.2.0

package/dist/scanner.js

@@ -1,423 +0,0 @@
-import { execFile } from "node:child_process";
-import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { createHash } from "node:crypto";
-import * as os from "node:os";
-import { logger } from "./log.js";
-import { agentbeanHome, localAgentsDir } from "./profile-paths.js";
-function readDaemonVersion() {
-    try {
-        const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-        return typeof packageJson.version === "string" ? packageJson.version : "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
-const DAEMON_VERSION = readDaemonVersion();
-function isExecutableFile(path) {
-    try {
-        return existsSync(path) && statSync(path).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function getExtraPathEntries() {
-    return [
-        '/usr/local/bin',
-        '/opt/homebrew/bin',
-        join(os.homedir(), '.local/bin'),
-        join(os.homedir(), '.bun/bin'),
-        join(os.homedir(), '.npm-global/bin'),
-        join(os.homedir(), '.asdf/shims'),
-        join(os.homedir(), '.local/share/mise/shims'),
-        ...getAllNodeVersions().map((version) => join(os.homedir(), '.nvm/versions/node', version, 'bin')),
-    ];
-}
-function which(bin, candidatePaths = []) {
-    return new Promise((resolve) => {
-        for (const candidate of candidatePaths) {
-            if (isExecutableFile(candidate)) {
-                resolve(candidate);
-                return;
-            }
-        }
-        const child = execFile('which', [bin], { timeout: 5_000, env: { ...process.env, PATH: [process.env.PATH, ...getExtraPathEntries()].filter(Boolean).join(':') } }, (err, stdout) => {
-            if (err) {
-                resolve(null);
-                return;
-            }
-            const path = stdout.trim();
-            resolve(path.length > 0 ? path : null);
-        });
-        child.on('error', () => resolve(null));
-    });
-}
-function getAllNodeVersions() {
-    try {
-        const nvmDir = join(os.homedir(), '.nvm/versions/node');
-        if (!existsSync(nvmDir))
-            return [];
-        return readdirSync(nvmDir);
-    }
-    catch {
-        return [];
-    }
-}
-function getClaudeCodeCandidates() {
-    const latestDir = join(os.homedir(), '.local/share/claude-latest');
-    const legacyDir = join(os.homedir(), '.local/share/claude');
-    const candidates = [
-        join(latestDir, 'current/claude'),
-        join(legacyDir, 'current/claude'),
-        '/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/cli.js',
-        '/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js',
-    ];
-    for (const base of [latestDir, legacyDir]) {
-        const versionsDir = join(base, 'versions');
-        try {
-            if (!existsSync(versionsDir))
-                continue;
-            const versions = readdirSync(versionsDir).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-            for (const version of versions)
-                candidates.push(join(versionsDir, version, 'claude'));
-        }
-        catch {
-            // Ignore unreadable version directories and continue with other candidates.
-        }
-    }
-    return candidates;
-}
-function run(bin, args) {
-    return new Promise((resolve) => {
-        const child = execFile(bin, args, { timeout: 10_000 }, (err, stdout) => {
-            resolve(stdout?.trim() ?? "");
-        });
-        child.on("error", () => resolve(""));
-    });
-}
-export function parseOpenClawAgentId(output) {
-    if (!output.trim())
-        return null;
-    try {
-        const parsed = JSON.parse(output);
-        const list = Array.isArray(parsed)
-            ? parsed
-            : Array.isArray(parsed?.agents)
-                ? parsed.agents
-                : Array.isArray(parsed?.items)
-                    ? parsed.items
-                    : [];
-        for (const item of list) {
-            const id = typeof item === 'string'
-                ? item
-                : typeof item?.id === 'string'
-                    ? item.id
-                    : typeof item?.agentId === 'string'
-                        ? item.agentId
-                        : null;
-            if (id?.trim())
-                return id.trim();
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-// --- Machine ID (stable per-device identifier) ---
-const MACHINE_ID_FILE = () => join(agentbeanHome(), "device-id");
-function getFirstMacAddress() {
-    const ifaces = os.networkInterfaces();
-    for (const [name, addrs] of Object.entries(ifaces)) {
-        if (!addrs)
-            continue;
-        for (const addr of addrs) {
-            // Skip internal (loopback) and zero MAC
-            if (addr.internal)
-                continue;
-            if (addr.mac === "00:00:00:00:00:00")
-                continue;
-            return addr.mac;
-        }
-    }
-    return null;
-}
-async function readPlatformMachineId() {
-    const platform = os.platform();
-    try {
-        if (platform === "linux") {
-            if (existsSync("/etc/machine-id")) {
-                return readFileSync("/etc/machine-id", "utf-8").trim() || null;
-            }
-        }
-        else if (platform === "darwin") {
-            const output = await run("ioreg", [
-                "-rd1",
-                "-c",
-                "IOPlatformExpertDevice",
-            ]);
-            const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
-            if (match)
-                return match[1] ?? null;
-        }
-        else if (platform === "win32") {
-            const output = await run("reg", [
-                "query",
-                "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography",
-                "/v",
-                "MachineGuid",
-            ]);
-            const match = output.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
-            if (match)
-                return match[1] ?? null;
-        }
-    }
-    catch {
-        // fall through
-    }
-    return null;
-}
-/**
- * Get a stable device ID unique to this machine.
- * Priority: cached file > platform machine-id > MAC address > random UUID
- * Result is cached to ~/.agentbean/device-id
- */
-export async function getDeviceId() {
-    // 1. Read cached ID
-    const machineIdFile = MACHINE_ID_FILE();
-    if (existsSync(machineIdFile)) {
-        const cached = readFileSync(machineIdFile, "utf-8").trim();
-        if (cached)
-            return cached;
-    }
-    // 2. Collect hardware fingerprint
-    const parts = [];
-    const platformId = await readPlatformMachineId();
-    if (platformId)
-        parts.push(`platform:${platformId}`);
-    const mac = getFirstMacAddress();
-    if (mac)
-        parts.push(`mac:${mac}`);
-    parts.push(`hostname:${os.hostname()}`);
-    parts.push(`arch:${os.arch()}`);
-    parts.push(`platform:${os.platform()}`);
-    let deviceId;
-    if (parts.length > 2) {
-        // We have enough hardware info — generate deterministic ID
-        const hash = createHash("sha256").update(parts.join("|")).digest("hex");
-        // Format as UUID: 8-4-4-4-12
-        deviceId = [
-            hash.slice(0, 8),
-            hash.slice(8, 12),
-            hash.slice(12, 16),
-            hash.slice(16, 20),
-            hash.slice(20, 32),
-        ].join("-");
-    }
-    else {
-        // Fallback: random UUID
-        const { randomUUID } = await import("node:crypto");
-        deviceId = randomUUID();
-    }
-    // 3. Cache to file
-    try {
-        const dir = agentbeanHome();
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(machineIdFile, deviceId);
-    }
-    catch {
-        // non-fatal
-    }
-    return deviceId;
-}
-// --- Scan Coding Agent Runtimes (Claude Code, Codex, Kimi) ---
-export async function scanRuntimes() {
-    const checks = [
-        {
-            bin: "claude",
-            name: "Claude Code",
-            adapterKind: "claude-code",
-            candidates: getClaudeCodeCandidates(),
-        },
-        { bin: "codex", name: "Codex CLI", adapterKind: "codex", candidates: [] },
-        {
-            bin: "kimi-cli",
-            name: "Kimi CLI",
-            adapterKind: "Kimi-cli",
-            candidates: [],
-        },
-    ];
-    const results = [];
-    for (const s of checks) {
-        const path = await which(s.bin, s.candidates);
-        results.push({
-            name: s.name,
-            adapterKind: s.adapterKind,
-            command: path ?? "",
-            installed: path !== null,
-        });
-    }
-    return results;
-}
-// --- Scan AgentOS Gateways (Hermes, OpenClaw) ---
-async function checkHermesGateway() {
-    const path = await which("hermes");
-    if (!path)
-        return null;
-    const status = await run("hermes", ["gateway", "status"]);
-    const running = status.includes("running") || status.includes("✓");
-    if (running) {
-        return {
-            category: "agentos-hosted",
-            name: "Hermes-Agent",
-            adapterKind: "hermes",
-            command: path,
-            args: [],
-            cwd: dirname(path),
-            source: "gateway",
-        };
-    }
-    return null;
-}
-async function checkOpenClawGateway() {
-    const path = await which("openclaw");
-    if (!path)
-        return null;
-    const status = await run(path, ["gateway", "status"]);
-    const running = status.includes("running") || status.includes("✓");
-    const agentId = parseOpenClawAgentId(await run(path, ["agents", "list", "--json"]));
-    if (running || agentId) {
-        return {
-            category: "agentos-hosted",
-            name: "OpenClaw-Agent",
-            adapterKind: "openclaw",
-            command: path,
-            args: ["agent", "--agent", agentId ?? "main"],
-            cwd: dirname(path),
-            source: "gateway",
-        };
-    }
-    return null;
-}
-export async function scanAgentOSAgents() {
-    const [hermes, openclaw] = await Promise.all([
-        checkHermesGateway(),
-        checkOpenClawGateway(),
-    ]);
-    return [hermes, openclaw].filter((a) => a !== null);
-}
-// --- Scan local agent definitions from filesystem ---
-export async function scanLocalAgents(scanDir = localAgentsDir(process.env.AGENTBEAN_PROFILE)) {
-    if (!existsSync(scanDir)) {
-        return [];
-    }
-    const results = [];
-    let entries;
-    try {
-        entries = readdirSync(scanDir);
-    }
-    catch (err) {
-        logger?.warn?.({ err: err?.message }, "scan failed");
-        return [];
-    }
-    for (const entry of entries) {
-        const subdir = join(scanDir, entry);
-        let st;
-        try {
-            st = statSync(subdir);
-        }
-        catch {
-            continue;
-        }
-        if (!st.isDirectory())
-            continue;
-        const jsonPath = join(subdir, "agent.json");
-        const yamlPath = join(subdir, "agent.yaml");
-        const ymlPath = join(subdir, "agent.yml");
-        let raw = null;
-        let ext = null;
-        if (existsSync(jsonPath)) {
-            raw = readFileSync(jsonPath, "utf8");
-            ext = "json";
-        }
-        else if (existsSync(yamlPath)) {
-            raw = readFileSync(yamlPath, "utf8");
-            ext = "yaml";
-        }
-        else if (existsSync(ymlPath)) {
-            raw = readFileSync(ymlPath, "utf8");
-            ext = "yaml";
-        }
-        if (raw === null || ext === null)
-            continue;
-        let parsed = null;
-        try {
-            if (ext === "json") {
-                parsed = JSON.parse(raw);
-            }
-            else {
-                const { load: parseYaml } = await import("js-yaml");
-                parsed = parseYaml(raw);
-            }
-        }
-        catch {
-            continue;
-        }
-        if (!parsed || typeof parsed !== "object")
-            continue;
-        const name = (typeof parsed.name === "string" ? parsed.name : entry).replace(/\s+/g, "-");
-        const command = typeof parsed.command === "string" ? parsed.command : "";
-        const args = Array.isArray(parsed.args)
-            ? parsed.args.map(String)
-            : [];
-        let category;
-        if (typeof parsed.category === "string" &&
-            ["executor-hosted", "agentos-hosted"].includes(parsed.category)) {
-            category = parsed.category;
-        }
-        else if ("executor" in parsed) {
-            category = "executor-hosted";
-        }
-        else {
-            category = "executor-hosted";
-        }
-        const adapterKind = typeof parsed.adapterKind === "string" &&
-            ["codex", "claude-code", "openclaw", "hermes"].includes(parsed.adapterKind)
-            ? parsed.adapterKind
-            : "codex";
-        results.push({
-            category,
-            name,
-            adapterKind,
-            command,
-            args,
-            source: "filesystem",
-        });
-    }
-    return results;
-}
-export function collectSystemInfo() {
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const cpus = os.cpus();
-    const platform = os.platform();
-    let osVersion = `${os.type()} ${os.release()}`;
-    if (platform === "darwin") {
-        osVersion = `macOS ${os.release()}`;
-    }
-    return {
-        platform,
-        arch: os.arch(),
-        osVersion,
-        hostname: os.hostname(),
-        cpuModel: cpus[0]?.model ?? "unknown",
-        cpuCores: cpus.length,
-        totalMemoryGB: Math.round((totalMem / 1024 / 1024 / 1024) * 10) / 10,
-        freeMemoryGB: Math.round((freeMem / 1024 / 1024 / 1024) * 10) / 10,
-        nodeVersion: process.version,
-        daemonVersion: DAEMON_VERSION,
-    };
-}

package/dist/uploader.js

@@ -1,46 +0,0 @@
-import { readFileSync, statSync } from 'node:fs';
-import { basename } from 'node:path';
-import { logger } from './log.js';
-export async function uploadArtifact(input) {
-    const { serverUrl, token, networkId, filePath, channelId, uploaderId, metaJson } = input;
-    const filename = basename(filePath);
-    let buffer;
-    let size;
-    try {
-        const st = statSync(filePath);
-        size = st.size;
-        buffer = readFileSync(filePath);
-    }
-    catch (err) {
-        logger.warn({ err: err.message, filePath }, 'artifact read failed');
-        return null;
-    }
-    // Node Buffer is a Uint8Array; cast to satisfy strict DOM types
-    const blob = new Blob([buffer]);
-    const form = new FormData();
-    form.append('channelId', channelId);
-    form.append('file', blob, filename);
-    if (uploaderId)
-        form.append('uploaderId', uploaderId);
-    if (metaJson)
-        form.append('metaJson', metaJson);
-    try {
-        const resp = await fetch(`${serverUrl}/api/networks/${networkId}/artifacts/upload`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${token}` },
-            body: form,
-        });
-        if (!resp.ok) {
-            const text = await resp.text();
-            logger.warn({ status: resp.status, body: text, filePath }, 'artifact upload rejected');
-            return null;
-        }
-        const result = (await resp.json());
-        logger.info({ id: result.id, filename, sizeBytes: size }, 'artifact uploaded');
-        return result;
-    }
-    catch (err) {
-        logger.warn({ err: err.message, filePath }, 'artifact upload failed');
-        return null;
-    }
-}

package/dist/workspace-manager.js

@@ -1,196 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
-import { homedir } from 'node:os';
-function rootDir() {
-    return resolve(process.env.AGENTBEAN_HOME ?? join(homedir(), '.agentbean'));
-}
-function safeSegment(value) {
-    return value.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
-}
-function ensureDir(dir) {
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    return dir;
-}
-export function getAgentWorkspaceDir(teamId, agentId) {
-    return ensureDir(join(rootDir(), 'teams', safeSegment(teamId), 'agents', safeSegment(agentId)));
-}
-function writeJson(path, value) {
-    ensureDir(dirname(path));
-    writeFileSync(path, JSON.stringify(value, null, 2));
-}
-function fileHash(path) {
-    return createHash('sha256').update(readFileSync(path)).digest('hex');
-}
-function uniqueDestination(dir, filename) {
-    const ext = extname(filename);
-    const stem = ext ? filename.slice(0, -ext.length) : filename;
-    let candidate = join(dir, filename);
-    let index = 1;
-    while (existsSync(candidate)) {
-        candidate = join(dir, `${stem}-${index}${ext}`);
-        index += 1;
-    }
-    return candidate;
-}
-function fileNamePreference(path) {
-    const name = basename(path).toLowerCase();
-    if (/^ig_[a-f0-9]{32,}\.(png|jpe?g|gif|webp)$/i.test(name))
-        return 0;
-    if (/^(image|output|generated)[._-]?\d*\.(png|jpe?g|gif|webp)$/i.test(name))
-        return 1;
-    return 2;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function replaceAllLiteral(value, search, replacement) {
-    if (!search || search === replacement)
-        return value;
-    return value.replace(new RegExp(escapeRegExp(search), 'g'), replacement);
-}
-function stripDevicePath(value, replacement) {
-    let body = replaceAllLiteral(value, `file://${replacement}`, basename(replacement));
-    body = replaceAllLiteral(body, replacement, basename(replacement));
-    return body;
-}
-export function beginAgentWorkspaceRun(input) {
-    const teamId = safeSegment(input.teamId);
-    const agentId = safeSegment(input.agentId);
-    const runId = safeSegment(input.runId);
-    const teamDir = ensureDir(join(rootDir(), 'teams', teamId));
-    const agentDir = ensureDir(join(teamDir, 'agents', agentId));
-    const runDir = ensureDir(join(agentDir, 'runs', runId));
-    const inputDir = ensureDir(join(runDir, 'inputs'));
-    const outputDir = ensureDir(join(runDir, 'outputs'));
-    const intermediateDir = ensureDir(join(runDir, 'intermediates'));
-    const logDir = ensureDir(join(runDir, 'logs'));
-    writeJson(join(teamDir, 'team.json'), {
-        id: input.teamId,
-        name: input.teamName ?? input.teamId,
-        updatedAt: new Date().toISOString(),
-    });
-    writeJson(join(agentDir, 'agent.json'), {
-        id: input.agentId,
-        name: input.agentName ?? input.agentId,
-        projectDir: input.projectDir ?? null,
-        updatedAt: new Date().toISOString(),
-    });
-    writeFileSync(join(runDir, 'prompt.md'), input.prompt);
-    writeJson(join(runDir, 'manifest.json'), {
-        teamId: input.teamId,
-        agentId: input.agentId,
-        runId: input.runId,
-        status: 'running',
-        createdAt: new Date().toISOString(),
-        files: [],
-    });
-    return { teamId: input.teamId, agentId: input.agentId, runId: input.runId, agentDir, runDir, inputDir, outputDir, intermediateDir, logDir };
-}
-export function workspaceEnv(run) {
-    return {
-        AGENTBEAN_TEAM_ID: run.teamId,
-        AGENTBEAN_AGENT_ID: run.agentId,
-        AGENTBEAN_RUN_ID: run.runId,
-        AGENTBEAN_WORKSPACE: run.agentDir,
-        AGENTBEAN_INPUT_DIR: run.inputDir,
-        AGENTBEAN_OUTPUT_DIR: run.outputDir,
-        AGENTBEAN_INTERMEDIATE_DIR: run.intermediateDir,
-        AGENT_BEAN_OUTPUT_DIRS: [run.outputDir, run.intermediateDir].join(','),
-    };
-}
-export function archiveOutputFiles(run, files) {
-    const archived = [];
-    const candidates = new Map();
-    const hashOrder = [];
-    const seenPaths = new Set();
-    for (const file of files) {
-        const abs = isAbsolute(file) ? file : resolve(file);
-        if (seenPaths.has(abs))
-            continue;
-        seenPaths.add(abs);
-        let st;
-        try {
-            st = statSync(abs);
-            if (!st.isFile())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        const hash = fileHash(abs);
-        const current = candidates.get(hash);
-        if (!current) {
-            candidates.set(hash, { abs, hash });
-            hashOrder.push(hash);
-        }
-        else if (fileNamePreference(abs) > fileNamePreference(current.abs)) {
-            candidates.set(hash, { abs, hash });
-        }
-    }
-    for (const hash of hashOrder) {
-        const candidate = candidates.get(hash);
-        if (!candidate)
-            continue;
-        const abs = candidate.abs;
-        const alreadyInRun = relative(run.runDir, abs);
-        const archivedPath = alreadyInRun && !alreadyInRun.startsWith('..') && !isAbsolute(alreadyInRun)
-            ? abs
-            : uniqueDestination(run.outputDir, basename(abs));
-        if (archivedPath !== abs)
-            copyFileSync(abs, archivedPath);
-        const sizeBytes = statSync(archivedPath).size;
-        archived.push({
-            originalPath: abs,
-            archivedPath,
-            relativePath: relative(run.agentDir, archivedPath),
-            pathKind: 'output',
-            sha256: candidate.hash,
-            sizeBytes,
-        });
-    }
-    return archived;
-}
-export function formatWorkspaceReply(reply, files, options = {}) {
-    const exposeLocalPaths = options.exposeLocalPaths ?? true;
-    let body = reply;
-    for (const file of files) {
-        if (exposeLocalPaths) {
-            body = replaceAllLiteral(body, `file://${file.originalPath}`, `file://${file.archivedPath}`);
-            body = replaceAllLiteral(body, file.originalPath, file.archivedPath);
-        }
-        else {
-            body = stripDevicePath(body, file.originalPath);
-            body = stripDevicePath(body, file.archivedPath);
-        }
-    }
-    const missingPaths = files.filter((file) => {
-        const marker = exposeLocalPaths ? file.archivedPath : basename(file.archivedPath);
-        return !body.includes(marker);
-    });
-    if (missingPaths.length > 0) {
-        body += '\n\n已生成文件:\n' + missingPaths.map((file) => `- ${exposeLocalPaths ? file.archivedPath : basename(file.archivedPath)}`).join('\n');
-    }
-    return body;
-}
-export function finishAgentWorkspaceRun(run, input) {
-    if (input.replyText !== undefined) {
-        writeFileSync(join(run.runDir, 'response.md'), input.replyText);
-    }
-    writeJson(join(run.runDir, 'manifest.json'), {
-        teamId: run.teamId,
-        agentId: run.agentId,
-        runId: run.runId,
-        status: input.status,
-        updatedAt: new Date().toISOString(),
-        error: input.error,
-        files: input.files.map((file) => ({
-            path: file.relativePath,
-            sha256: file.sha256,
-            sizeBytes: file.sizeBytes,
-            kind: file.pathKind,
-            originalPath: file.originalPath,
-        })),
-    });
-}