agent-remnote 0.0.1 → 0.0.2

package/dist/apps/cli/src/main.js

@@ -0,0 +1,79 @@
+import { Command } from '@effect/cli';
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import * as ValidationError from '@effect/cli/ValidationError';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Option from 'effect/Option';
+import { rootCommand } from './commands/index.js';
+import { cliErrorFromValidationError, exitCodeFromExit, fail, isCliError, toJsonError, } from './services/Errors.js';
+const cli = Command.run(rootCommand, {
+    name: 'remnote',
+    version: '0.0.1',
+});
+const jsonRequested = process.argv.includes('--json');
+const debugRequested = process.argv.includes('--debug');
+cli(process.argv)
+    .pipe(Effect.provide(NodeContext.layer), Effect.exit, Effect.flatMap((exit) => Effect.sync(() => {
+    process.exitCode = exitCodeFromExit(exit);
+    if (Exit.isSuccess(exit))
+        return;
+    const failure = Cause.failureOption(exit.cause);
+    if (Option.isNone(failure)) {
+        if (jsonRequested) {
+            process.stdout.write(`${JSON.stringify(fail({
+                code: 'INTERNAL',
+                message: '未知运行时错误（defect）',
+                details: debugRequested ? { cause: Cause.pretty(exit.cause) } : undefined,
+            }))}\n`);
+        }
+        else if (!globalThis.__REMNOTE_CLI_ERROR_REPORTED__) {
+            ;
+            globalThis.__REMNOTE_CLI_ERROR_REPORTED__ = true;
+            process.stderr.write('未知运行时错误（defect）\n');
+            if (debugRequested)
+                process.stderr.write(Cause.pretty(exit.cause) + '\n');
+        }
+        return;
+    }
+    const error = failure.value;
+    if (ValidationError.isValidationError(error)) {
+        if (!jsonRequested)
+            return;
+        const cliError = cliErrorFromValidationError(error);
+        process.stdout.write(`${JSON.stringify(fail(toJsonError(cliError), cliError.hint))}\n`);
+        return;
+    }
+    if (isCliError(error)) {
+        if (jsonRequested) {
+            process.stdout.write(`${JSON.stringify(fail(toJsonError(error), error.hint))}\n`);
+            return;
+        }
+        if (!globalThis.__REMNOTE_CLI_ERROR_REPORTED__) {
+            ;
+            globalThis.__REMNOTE_CLI_ERROR_REPORTED__ = true;
+            process.stderr.write(`${error.message}\n`);
+            if (debugRequested && error.details !== undefined) {
+                process.stderr.write(`${JSON.stringify(error.details, null, 2)}\n`);
+            }
+            if (error.hint && error.hint.length > 0) {
+                process.stderr.write('Hint:\n');
+                for (const h of error.hint)
+                    process.stderr.write(`- ${h}\n`);
+            }
+        }
+        return;
+    }
+    if (jsonRequested) {
+        process.stdout.write(`${JSON.stringify(fail({
+            code: 'INTERNAL',
+            message: String(error?.message || error || '未知错误'),
+        }))}\n`);
+    }
+    else if (!globalThis.__REMNOTE_CLI_ERROR_REPORTED__) {
+        ;
+        globalThis.__REMNOTE_CLI_ERROR_REPORTED__ = true;
+        process.stderr.write(String(error?.message || error || '未知错误') + '\n');
+    }
+})))
+    .pipe(NodeRuntime.runMain);

package/dist/apps/cli/src/services/AppConfig.js

@@ -0,0 +1,3 @@
+import * as Context from 'effect/Context';
+export class AppConfig extends Context.Tag('AppConfig')() {
+}

package/dist/apps/cli/src/services/Config.js

@@ -0,0 +1,91 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { CliError, isCliError } from './Errors.js';
+export class Config extends Context.Tag('Config')() {
+}
+function expandHome(targetPath) {
+    if (!targetPath.startsWith('~'))
+        return targetPath;
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    if (targetPath === '~')
+        return home;
+    if (targetPath.startsWith('~/'))
+        return `${home}/${targetPath.slice(2)}`;
+    return targetPath.replace(/^~(?=$|\/)/, home);
+}
+function defaultQueueDbPath() {
+    const env = process.env.REMNOTE_QUEUE_DB || process.env.QUEUE_DB;
+    if (typeof env === 'string' && env.trim())
+        return expandHome(env.trim());
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    return `${home}/.remnote-mcp/queue.sqlite`;
+}
+function defaultWsUrl() {
+    const env = process.env.WS_URL;
+    if (typeof env === 'string' && env.trim())
+        return env.trim();
+    return 'ws://localhost:3010/ws';
+}
+function defaultConsumerId() {
+    const env = process.env.REMNOTE_CONSUMER_ID;
+    if (typeof env === 'string' && env.trim())
+        return env.trim();
+    return 'remnote-plugin';
+}
+function defaultRepo() {
+    const env = process.env.REMNOTE_MCP_REPO;
+    return typeof env === 'string' && env.trim() ? expandHome(env.trim()) : undefined;
+}
+function pickFormat(flags) {
+    const json = flags.json === true;
+    const md = flags.md === true;
+    const ids = flags.ids === true;
+    const count = [json, md, ids].filter(Boolean).length;
+    if (count > 1) {
+        throw new CliError({
+            code: 'INVALID_ARGS',
+            message: '输出模式冲突：--json/--md/--ids 只能选择一个',
+            exitCode: 2,
+            details: { json, md, ids },
+        });
+    }
+    if (json)
+        return 'json';
+    if (ids)
+        return 'ids';
+    // 默认输出：md
+    return 'md';
+}
+export function resolveConfig(flags) {
+    return Effect.try({
+        try: () => {
+            const remnoteDbRaw = (flags.remnoteDb ?? process.env.REMNOTE_DB)?.trim();
+            const queueDbRaw = flags.queueDb?.trim();
+            const wsUrlRaw = flags.wsUrl?.trim();
+            const consumerIdRaw = flags.consumerId?.trim();
+            const repoRaw = flags.repo?.trim();
+            return {
+                format: pickFormat(flags),
+                quiet: flags.quiet === true,
+                debug: flags.debug === true,
+                remnoteDb: remnoteDbRaw ? expandHome(remnoteDbRaw) : undefined,
+                queueDb: expandHome(queueDbRaw || defaultQueueDbPath()),
+                wsUrl: wsUrlRaw || defaultWsUrl(),
+                consumerId: consumerIdRaw || defaultConsumerId(),
+                repo: repoRaw ? expandHome(repoRaw) : defaultRepo(),
+            };
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '解析配置失败',
+                exitCode: 1,
+                details: { error: String(error?.message || error) },
+            });
+        },
+    });
+}
+export const ConfigLive = Layer.succeed(Config, { resolve: resolveConfig });

package/dist/apps/cli/src/services/DaemonFiles.js

@@ -0,0 +1,91 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { CliError, isCliError } from './Errors.js';
+export class DaemonFiles extends Context.Tag('DaemonFiles')() {
+}
+function homeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '.';
+}
+function ensureDir(p) {
+    return fs.mkdir(path.dirname(p), { recursive: true }).then(() => undefined);
+}
+function defaultPidFile() {
+    return path.join(homeDir(), '.remnote-mcp', 'ws.pid');
+}
+function defaultLogFile() {
+    return path.join(homeDir(), '.remnote-mcp', 'ws.log');
+}
+async function writeJsonAtomic(filePath, json) {
+    await ensureDir(filePath);
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tmp, JSON.stringify(json), 'utf8');
+    await fs.rename(tmp, filePath);
+}
+export const DaemonFilesLive = Layer.succeed(DaemonFiles, {
+    defaultPidFile: () => defaultPidFile(),
+    defaultLogFile: () => defaultLogFile(),
+    readPidFile: (pidFilePath) => Effect.tryPromise({
+        try: async () => {
+            try {
+                const raw = await fs.readFile(pidFilePath, 'utf8');
+                const parsed = JSON.parse(raw);
+                return parsed;
+            }
+            catch (error) {
+                if (error?.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            }
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '读取 pidfile 失败',
+                exitCode: 1,
+                details: { pid_file: pidFilePath, error: String(error?.message || error) },
+            });
+        },
+    }),
+    writePidFile: (pidFilePath, value) => Effect.tryPromise({
+        try: async () => {
+            await writeJsonAtomic(pidFilePath, value);
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '写入 pidfile 失败',
+                exitCode: 1,
+                details: { pid_file: pidFilePath, error: String(error?.message || error) },
+            });
+        },
+    }),
+    deletePidFile: (pidFilePath) => Effect.tryPromise({
+        try: async () => {
+            try {
+                await fs.unlink(pidFilePath);
+            }
+            catch (error) {
+                if (error?.code === 'ENOENT')
+                    return;
+                throw error;
+            }
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '删除 pidfile 失败',
+                exitCode: 1,
+                details: { pid_file: pidFilePath, error: String(error?.message || error) },
+            });
+        },
+    }),
+});

package/dist/apps/cli/src/services/Errors.js

@@ -0,0 +1,49 @@
+import * as Data from 'effect/Data';
+import * as Exit from 'effect/Exit';
+import * as Cause from 'effect/Cause';
+import * as Option from 'effect/Option';
+import * as ValidationError from '@effect/cli/ValidationError';
+import * as HelpDoc from '@effect/cli/HelpDoc';
+export class CliError extends Data.TaggedError('CliError') {
+}
+export function isCliError(u) {
+    return typeof u === 'object' && u !== null && u._tag === 'CliError';
+}
+export function ok(data) {
+    return { ok: true, data };
+}
+export function fail(error, hint) {
+    return hint && hint.length > 0 ? { ok: false, error, hint } : { ok: false, error };
+}
+export function toJsonError(error) {
+    return { code: error.code, message: error.message, details: error.details };
+}
+export function stripAnsi(input) {
+    return input.replace(/\u001b\[[0-9;]*m/g, '');
+}
+export function renderValidationErrorMessage(err) {
+    return stripAnsi(HelpDoc.toAnsiText(err.error)).trim();
+}
+export function cliErrorFromValidationError(err) {
+    return new CliError({
+        code: 'INVALID_ARGS',
+        message: renderValidationErrorMessage(err) || 'Invalid arguments',
+        details: { tag: err._tag },
+        exitCode: 2,
+    });
+}
+export function exitCodeFromExit(exit) {
+    if (Exit.isSuccess(exit))
+        return 0;
+    if (Cause.isInterruptedOnly(exit.cause))
+        return 0;
+    const failure = Cause.failureOption(exit.cause);
+    if (Option.isSome(failure)) {
+        const error = failure.value;
+        if (isCliError(error))
+            return error.exitCode;
+        if (ValidationError.isValidationError(error))
+            return 2;
+    }
+    return 1;
+}

package/dist/apps/cli/src/services/Output.js

@@ -0,0 +1,16 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+export class Output extends Context.Tag('Output')() {
+}
+export const OutputLive = Layer.succeed(Output, {
+    stdout: (text) => Effect.sync(() => {
+        process.stdout.write(text);
+    }),
+    stderr: (text) => Effect.sync(() => {
+        process.stderr.write(text);
+    }),
+    json: (value) => Effect.sync(() => {
+        process.stdout.write(`${JSON.stringify(value)}\n`);
+    }),
+});

package/dist/apps/cli/src/services/Payload.js

@@ -0,0 +1,90 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { promises as fs } from 'node:fs';
+import { CliError } from './Errors.js';
+export class Payload extends Context.Tag('Payload')() {
+}
+const MAX_PAYLOAD_BYTES = 5 * 1024 * 1024;
+function decamelize(s) {
+    return s
+        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1_$2')
+        .toLowerCase();
+}
+function normalizeKeys(value) {
+    if (value == null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => normalizeKeys(v));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        out[decamelize(k)] = normalizeKeys(v);
+    }
+    return out;
+}
+async function readAllStdin() {
+    if (process.stdin.isTTY) {
+        throw new CliError({
+            code: 'INVALID_ARGS',
+            message: '使用 --payload - 时需要从 stdin 管道输入 JSON',
+            exitCode: 2,
+        });
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function readPayloadSpec(spec) {
+    if (spec === '-') {
+        return await readAllStdin();
+    }
+    if (spec.startsWith('@')) {
+        const filePath = spec.slice(1).trim();
+        if (!filePath) {
+            throw new CliError({ code: 'INVALID_ARGS', message: 'payload 文件路径不能为空', exitCode: 2 });
+        }
+        return await fs.readFile(filePath, 'utf8');
+    }
+    return spec;
+}
+export const PayloadLive = Layer.succeed(Payload, {
+    readJson: (spec) => Effect.tryPromise({
+        try: async () => {
+            const raw = await readPayloadSpec(spec);
+            const bytes = Buffer.byteLength(raw, 'utf8');
+            if (bytes > MAX_PAYLOAD_BYTES) {
+                throw new CliError({
+                    code: 'PAYLOAD_TOO_LARGE',
+                    message: `payload 过大（${bytes} bytes），请拆分后重试`,
+                    exitCode: 2,
+                    details: { bytes, max_bytes: MAX_PAYLOAD_BYTES },
+                });
+            }
+            try {
+                return JSON.parse(raw);
+            }
+            catch (error) {
+                throw new CliError({
+                    code: 'INVALID_PAYLOAD',
+                    message: 'payload 不是合法 JSON',
+                    exitCode: 2,
+                    details: { error: String(error?.message || error) },
+                });
+            }
+        },
+        catch: (error) => {
+            if (error && typeof error === 'object' && error._tag === 'CliError')
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '读取 payload 失败',
+                exitCode: 1,
+                details: { error: String(error?.message || error) },
+            });
+        },
+    }),
+    normalizeKeys,
+});

package/dist/apps/cli/src/services/Process.js

@@ -0,0 +1,94 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CliError, isCliError } from './Errors.js';
+export class Process extends Context.Tag('Process')() {
+}
+function ensureDirSync(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+export const ProcessLive = Layer.succeed(Process, {
+    isPidRunning: (pid) => Effect.sync(() => {
+        if (!Number.isFinite(pid) || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error?.code === 'EPERM')
+                return true;
+            return false;
+        }
+    }),
+    spawnDetached: (params) => Effect.try({
+        try: () => {
+            ensureDirSync(params.logFile);
+            const fd = fs.openSync(params.logFile, 'a');
+            const child = spawn(params.command, [...params.args], {
+                cwd: params.cwd,
+                env: params.env,
+                detached: true,
+                stdio: ['ignore', fd, fd],
+            });
+            child.unref();
+            return child.pid;
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'INTERNAL',
+                message: '启动后台进程失败',
+                exitCode: 1,
+                details: { error: String(error?.message || error) },
+            });
+        },
+    }).pipe(Effect.flatMap((pid) => {
+        if (typeof pid !== 'number' || !Number.isFinite(pid)) {
+            return Effect.fail(new CliError({
+                code: 'INTERNAL',
+                message: '启动后台进程失败（pid 不可用）',
+                exitCode: 1,
+            }));
+        }
+        return Effect.succeed(pid);
+    })),
+    kill: (pid, signal) => Effect.try({
+        try: () => {
+            process.kill(pid, signal);
+        },
+        catch: (error) => new CliError({
+            code: 'INTERNAL',
+            message: `发送信号失败（${signal}）`,
+            exitCode: 1,
+            details: { pid, signal, error: String(error?.message || error) },
+        }),
+    }),
+    waitForExit: ({ pid, timeoutMs }) => Effect.async((resume) => {
+        const deadline = Date.now() + Math.max(0, timeoutMs);
+        const tick = () => {
+            let alive = false;
+            try {
+                process.kill(pid, 0);
+                alive = true;
+            }
+            catch (error) {
+                alive = error?.code === 'EPERM';
+            }
+            if (!alive) {
+                resume(Effect.succeed(true));
+                return;
+            }
+            if (Date.now() >= deadline) {
+                resume(Effect.succeed(false));
+                return;
+            }
+            setTimeout(tick, 100);
+        };
+        tick();
+    }),
+});

package/dist/apps/cli/src/services/Queue.js

@@ -0,0 +1,120 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { CliError, isCliError } from './Errors.js';
+import { enqueueTxn, getTxnIdByOpId, openQueueDb, queueStats as getQueueStats } from '../adapters/mcp.js';
+export class Queue extends Context.Tag('Queue')() {
+}
+function safeParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+export const QueueLive = Layer.succeed(Queue, {
+    enqueue: ({ dbPath, ops, options }) => Effect.try({
+        try: () => {
+            const db = openQueueDb(dbPath);
+            try {
+                const txn_id = enqueueTxn(db, ops, options);
+                const opRows = db
+                    .prepare(`SELECT op_id FROM ops WHERE txn_id=? ORDER BY op_seq ASC`)
+                    .all(txn_id);
+                const op_ids = opRows.map((r) => String(r.op_id));
+                return { txn_id, op_ids };
+            }
+            finally {
+                db.close();
+            }
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'QUEUE_UNAVAILABLE',
+                message: '队列数据库不可用',
+                exitCode: 1,
+                details: { db_path: dbPath, error: String(error?.message || error) },
+            });
+        },
+    }),
+    stats: ({ dbPath }) => Effect.try({
+        try: () => {
+            const db = openQueueDb(dbPath);
+            try {
+                return getQueueStats(db);
+            }
+            finally {
+                db.close();
+            }
+        },
+        catch: (error) => new CliError({
+            code: 'QUEUE_UNAVAILABLE',
+            message: '队列数据库不可用',
+            exitCode: 1,
+            details: { db_path: dbPath, error: String(error?.message || error) },
+        }),
+    }),
+    inspect: ({ dbPath, txnId, opId }) => Effect.try({
+        try: () => {
+            const db = openQueueDb(dbPath);
+            try {
+                let resolvedTxnId = txnId;
+                if (!resolvedTxnId && opId) {
+                    resolvedTxnId = getTxnIdByOpId(db, opId);
+                }
+                if (!resolvedTxnId) {
+                    throw new CliError({
+                        code: 'INVALID_ARGS',
+                        message: '必须提供 --txn 或 --op',
+                        exitCode: 2,
+                    });
+                }
+                const txn = db.prepare(`SELECT * FROM txns WHERE txn_id=?`).get(resolvedTxnId);
+                if (!txn) {
+                    throw new CliError({
+                        code: 'INVALID_ARGS',
+                        message: `未找到事务 ${resolvedTxnId}`,
+                        exitCode: 2,
+                    });
+                }
+                const ops = db.prepare(`SELECT * FROM ops WHERE txn_id=? ORDER BY op_seq ASC`).all(resolvedTxnId);
+                const results = ops.length === 0
+                    ? []
+                    : db
+                        .prepare(`SELECT * FROM op_results WHERE op_id IN (${ops.map(() => '?').join(',')})`)
+                        .all(...ops.map((o) => o.op_id));
+                const resMap = new Map();
+                for (const r of results)
+                    resMap.set(String(r.op_id), r);
+                const idMap = db.prepare(`SELECT * FROM id_map WHERE source_txn=?`).all(resolvedTxnId);
+                const detail = ops.map((o) => ({
+                    op_id: String(o.op_id),
+                    seq: o.op_seq,
+                    type: o.type,
+                    status: o.status,
+                    attempts: o.attempt_count,
+                    next_attempt_at: o.next_attempt_at,
+                    payload: safeParseJson(o.payload_json),
+                    result: resMap.get(String(o.op_id)) || null,
+                }));
+                return { txn, ops: detail, id_map: idMap };
+            }
+            finally {
+                db.close();
+            }
+        },
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'QUEUE_UNAVAILABLE',
+                message: '队列数据库不可用',
+                exitCode: 1,
+                details: { db_path: dbPath, error: String(error?.message || error) },
+            });
+        },
+    }),
+});