agent-remnote 0.0.1 → 0.1.0

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

@@ -0,0 +1,111 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { executeSearchRemOverview } from '../adapters/mcp.js';
+import { AppConfig } from './AppConfig.js';
+import { CliError } from './Errors.js';
+export class RefResolver extends Context.Tag('RefResolver')() {
+}
+function stripQuotes(s) {
+    const t = s.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+function parseRef(input) {
+    const raw = input.trim();
+    const idx = raw.indexOf(':');
+    if (idx <= 0) {
+        throw new CliError({
+            code: 'INVALID_ARGS',
+            message: `ref 不合法：${input}`,
+            exitCode: 2,
+            hint: ['示例：--ref id:xxx', '示例：--ref title:Demo', '示例：--ref daily:today', '示例：--ref daily:-1'],
+        });
+    }
+    const kind = raw.slice(0, idx).trim();
+    const value = stripQuotes(raw.slice(idx + 1));
+    if (!value) {
+        throw new CliError({
+            code: 'INVALID_ARGS',
+            message: `ref 不合法（缺少值）：${input}`,
+            exitCode: 2,
+        });
+    }
+    if (kind === 'id' || kind === 'title' || kind === 'daily') {
+        return { kind, value };
+    }
+    throw new CliError({
+        code: 'INVALID_ARGS',
+        message: `ref 不支持：${input}`,
+        exitCode: 2,
+        hint: ['支持：id:/title:/daily:'],
+    });
+}
+function parseDailyOffset(value) {
+    const v = value.trim().toLowerCase();
+    if (v === 'today' || v === 'now' || v === '0')
+        return 0;
+    if (v === 'yesterday')
+        return -1;
+    if (v === 'tomorrow')
+        return 1;
+    const n = Number.parseInt(v, 10);
+    if (!Number.isFinite(n)) {
+        throw new CliError({
+            code: 'INVALID_ARGS',
+            message: `daily ref 不合法：${value}（需要 today/yesterday/tomorrow 或整数偏移）`,
+            exitCode: 2,
+        });
+    }
+    return n;
+}
+export const RefResolverLive = Layer.succeed(RefResolver, {
+    resolve: (ref) => Effect.gen(function* () {
+        const cfg = yield* AppConfig;
+        const parsed = yield* Effect.try({
+            try: () => parseRef(ref),
+            catch: (e) => e && typeof e === 'object' && e._tag === 'CliError'
+                ? e
+                : new CliError({ code: 'INVALID_ARGS', message: `ref 不合法：${ref}`, exitCode: 2 }),
+        });
+        if (parsed.kind === 'id')
+            return parsed.value;
+        const dailyOffset = parsed.kind === 'daily'
+            ? yield* Effect.try({
+                try: () => parseDailyOffset(parsed.value),
+                catch: (e) => e && typeof e === 'object' && e._tag === 'CliError'
+                    ? e
+                    : new CliError({ code: 'INVALID_ARGS', message: `daily ref 不合法：${parsed.value}`, exitCode: 2 }),
+            })
+            : undefined;
+        const queryInput = parsed.kind === 'title'
+            ? { query: parsed.value }
+            : { query: 'date', useCurrentDate: true, dateOffsetDays: dailyOffset };
+        const result = yield* Effect.tryPromise({
+            try: async () => await executeSearchRemOverview({
+                ...queryInput,
+                dbPath: cfg.remnoteDb,
+                limit: 1,
+                preferExact: true,
+                exactFirstSingle: true,
+            }),
+            catch: (e) => new CliError({
+                code: 'DB_UNAVAILABLE',
+                message: String(e?.message || e || 'RemNote DB 不可用'),
+                exitCode: 1,
+            }),
+        });
+        const first = Array.isArray(result.matches) ? result.matches[0] : undefined;
+        const id = first?.id ? String(first.id) : '';
+        if (!id) {
+            return yield* Effect.fail(new CliError({
+                code: 'INVALID_ARGS',
+                message: `未找到 ref 对应的 Rem：${ref}`,
+                exitCode: 2,
+            }));
+        }
+        return id;
+    }),
+});

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

@@ -0,0 +1,35 @@
+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 { discoverBackups, withResolvedDatabase } from '../adapters/mcp.js';
+export class RemDb extends Context.Tag('RemDb')() {
+}
+export const RemDbLive = Layer.succeed(RemDb, {
+    withDb: (dbPath, fn) => Effect.tryPromise({
+        try: async () => await withResolvedDatabase(dbPath, fn),
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'DB_UNAVAILABLE',
+                message: String(error?.message || error || 'RemNote DB 不可用'),
+                exitCode: 1,
+                details: { db_path: dbPath },
+            });
+        },
+    }),
+    backups: (basePath) => Effect.tryPromise({
+        try: async () => await discoverBackups(basePath),
+        catch: (error) => {
+            if (isCliError(error))
+                return error;
+            return new CliError({
+                code: 'DB_UNAVAILABLE',
+                message: String(error?.message || error || '无法读取 RemNote 备份目录'),
+                exitCode: 1,
+                details: { base_path: basePath },
+            });
+        },
+    }),
+});

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

@@ -0,0 +1,170 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import WebSocket from 'ws';
+import { CliError } from './Errors.js';
+export class WsClient extends Context.Tag('WsClient')() {
+}
+function formatError(e) {
+    if (!e)
+        return 'unknown error';
+    if (typeof e === 'string')
+        return e;
+    const anyErr = e;
+    if (anyErr?.errors && Array.isArray(anyErr.errors)) {
+        const parts = anyErr.errors
+            .map((inner) => {
+            const code = inner?.code ? String(inner.code) : '';
+            const msg = inner?.message ? String(inner.message) : String(inner);
+            return code ? `${code}: ${msg}` : msg;
+        })
+            .filter(Boolean);
+        if (parts.length > 0)
+            return `AggregateError(${parts.join('; ')})`;
+    }
+    if (typeof anyErr?.message === 'string')
+        return anyErr.message;
+    return String(e);
+}
+function connectOnce(params) {
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(params.url);
+        let done = false;
+        const finishOk = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                ws.terminate();
+            }
+            catch (_) { }
+            resolve();
+        };
+        const finishErr = (error) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                ws.terminate();
+            }
+            catch (_) { }
+            reject(error);
+        };
+        const timer = setTimeout(() => {
+            finishErr(new Error(`timeout after ${params.timeoutMs}ms`));
+        }, params.timeoutMs);
+        ws.on('open', () => {
+            try {
+                params.onOpen(ws);
+            }
+            catch (e) {
+                finishErr(e);
+            }
+        });
+        ws.on('message', (data) => {
+            try {
+                const txt = String(data);
+                const msg = JSON.parse(txt);
+                params.onMessage(ws, msg);
+            }
+            catch (_) {
+                // ignore non-json
+            }
+        });
+        ws.on('error', (e) => {
+            finishErr(e);
+        });
+        ws.on('close', () => {
+            finishErr(new Error('connection closed'));
+        });
+        ws.__finishOk = finishOk;
+    });
+}
+export const WsClientLive = Layer.succeed(WsClient, {
+    health: ({ url, timeoutMs }) => Effect.tryPromise({
+        try: async () => {
+            const startedAt = Date.now();
+            await connectOnce({
+                url,
+                timeoutMs,
+                onOpen: (ws) => {
+                    ws.send(JSON.stringify({ type: 'Hello' }));
+                },
+                onMessage: (ws, msg) => {
+                    if (msg?.type === 'HelloAck' && msg?.ok === true) {
+                        ;
+                        ws.__finishOk?.();
+                    }
+                },
+            });
+            return { url, rtt_ms: Date.now() - startedAt };
+        },
+        catch: (error) => {
+            const message = formatError(error);
+            return new CliError({
+                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
+                message,
+                exitCode: 1,
+                details: { url, timeout_ms: timeoutMs },
+            });
+        },
+    }),
+    triggerStartSync: ({ url, timeoutMs, consumerId }) => Effect.tryPromise({
+        try: async () => {
+            let result;
+            await connectOnce({
+                url,
+                timeoutMs,
+                onOpen: (ws) => {
+                    ws.send(JSON.stringify({ type: 'TriggerStartSync', consumerId }));
+                },
+                onMessage: (ws, msg) => {
+                    if (msg?.type === 'StartSyncTriggered') {
+                        result = { sent: typeof msg?.sent === 'number' ? msg.sent : 0 };
+                        ws.__finishOk?.();
+                    }
+                },
+            });
+            return result ?? { sent: 0 };
+        },
+        catch: (error) => {
+            const message = formatError(error);
+            return new CliError({
+                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
+                message,
+                exitCode: 1,
+                details: { url, timeout_ms: timeoutMs, consumer_id: consumerId },
+            });
+        },
+    }),
+    queryClients: ({ url, timeoutMs }) => Effect.tryPromise({
+        try: async () => {
+            let result;
+            await connectOnce({
+                url,
+                timeoutMs,
+                onOpen: (ws) => {
+                    ws.send(JSON.stringify({ type: 'QueryClients' }));
+                },
+                onMessage: (ws, msg) => {
+                    if (msg?.type === 'Clients' && Array.isArray(msg?.clients)) {
+                        result = { clients: msg.clients };
+                        ws.__finishOk?.();
+                    }
+                },
+            });
+            return result ?? { clients: [] };
+        },
+        catch: (error) => {
+            const message = formatError(error);
+            return new CliError({
+                code: message.includes('timeout after') ? 'WS_TIMEOUT' : 'WS_UNAVAILABLE',
+                message,
+                exitCode: 1,
+                details: { url, timeout_ms: timeoutMs },
+            });
+        },
+    }),
+});

package/dist/apps/cli/tests/apply.contract.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: apply --dry-run --json', () => {
+    it('prints ok envelope and does not require queue db', async () => {
+        const payload = '[{"type":"create_rem","payload":{"fooBar":1}}]';
+        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', payload]);
+        expect(res.exitCode).toBe(0);
+        expect(res.stderr).toBe('');
+        const parsed = JSON.parse(res.stdout.trim());
+        expect(parsed.ok).toBe(true);
+        expect(parsed.data.dry_run).toBe(true);
+        expect(Array.isArray(parsed.data.ops)).toBe(true);
+        expect(parsed.data.ops[0].type).toBe('create_rem');
+        expect(parsed.data.ops[0].payload.foo_bar).toBe(1);
+    });
+    it('accepts object payload with meta (and normalizes keys)', async () => {
+        const payload = JSON.stringify({
+            ops: [{ type: 'create_rem', payload: { fooBar: 1 } }],
+            meta: { traceId: 't1', fooBar: 2 },
+            clientId: 'test-client',
+        });
+        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', payload]);
+        expect(res.exitCode).toBe(0);
+        expect(res.stderr).toBe('');
+        const parsed = JSON.parse(res.stdout.trim());
+        expect(parsed.ok).toBe(true);
+        expect(parsed.data.dry_run).toBe(true);
+        expect(parsed.data.meta.trace_id).toBe('t1');
+        expect(parsed.data.meta.foo_bar).toBe(2);
+    });
+});

package/dist/apps/cli/tests/db-recent.contract.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: db recent --json', () => {
+    it('prints a single json envelope and keeps stderr empty on db error', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
+        const missingDb = path.join(tmpDir, 'missing-remnote.db');
+        try {
+            const res = await runCli(['--json', '--remnote-db', missingDb, 'db', 'recent']);
+            expect(res.exitCode).toBe(1);
+            expect(res.stderr).toBe('');
+            const parsed = JSON.parse(res.stdout.trim());
+            expect(parsed.ok).toBe(false);
+            expect(parsed.error.code).toBe('DB_UNAVAILABLE');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/apps/cli/tests/help.contract.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { runCli } from './helpers/runCli.js';
+function stripAnsi(input) {
+    return input.replace(/\u001b\[[0-9;]*m/g, '');
+}
+describe('cli contract: --help', () => {
+    it('prints root help with subcommands', async () => {
+        const res = await runCli(['--help']);
+        expect(res.exitCode).toBe(0);
+        expect(res.stderr).toBe('');
+        const out = stripAnsi(res.stdout);
+        expect(out).toContain('remnote');
+        expect(out).toContain('ws');
+        expect(out).toContain('queue');
+        expect(out).toContain('apply');
+        expect(out).toContain('read');
+        expect(out).toContain('write');
+        expect(out).toContain('wechat');
+    });
+    it('prints ws help with subcommands', async () => {
+        const res = await runCli(['ws', '--help']);
+        expect(res.exitCode).toBe(0);
+        expect(res.stderr).toBe('');
+        const out = stripAnsi(res.stdout);
+        expect(out).toContain('health');
+        expect(out).toContain('start');
+        expect(out).toContain('stop');
+        expect(out).toContain('status');
+    });
+});

package/dist/apps/cli/tests/helpers/runCli.js

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export async function runCli(args, options) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const repoRoot = path.resolve(__dirname, '../../../../');
+    const entry = path.join(repoRoot, 'apps/cli/src/main.ts');
+    const timeoutMs = options?.timeoutMs ?? 30_000;
+    return await new Promise((resolve) => {
+        const child = spawn('bun', ['x', 'tsx', entry, ...args], {
+            cwd: repoRoot,
+            env: { ...process.env, ...(options?.env ?? {}) },
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (d) => {
+            stdout += d;
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d;
+        });
+        if (options?.stdin !== undefined) {
+            child.stdin.setDefaultEncoding('utf8');
+            child.stdin.write(options.stdin);
+            child.stdin.end();
+        }
+        else {
+            child.stdin.end();
+        }
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch (_) { }
+        }, timeoutMs);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ exitCode: typeof code === 'number' ? code : 1, stdout, stderr });
+        });
+    });
+}

package/dist/apps/cli/tests/ids-output.contract.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: --ids output', () => {
+    it('prints ids one per line', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
+        const tmpHome = path.join(tmpDir, 'home');
+        const queueDb = path.join(tmpDir, 'queue.sqlite');
+        try {
+            const payload = '[{"type":"create_rem","payload":{"text":"hello"}}]';
+            const res = await runCli(['--ids', 'apply', '--payload', payload], {
+                env: { HOME: tmpHome, REMNOTE_QUEUE_DB: queueDb },
+            });
+            expect(res.exitCode).toBe(0);
+            expect(res.stderr).toBe('');
+            const lines = res.stdout
+                .split(/\r?\n/)
+                .map((l) => l.trim())
+                .filter(Boolean);
+            expect(lines.length).toBe(2);
+            expect(lines[0].length).toBeGreaterThan(10);
+            expect(lines[1].length).toBeGreaterThan(10);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/apps/cli/tests/payload-stdin.contract.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: --payload - stdin', () => {
+    it('reads payload from stdin in dry-run mode', async () => {
+        const stdin = '[{"type":"create_rem","payload":{"fooBar":1}}]';
+        const res = await runCli(['--json', 'apply', '--dry-run', '--payload', '-'], { stdin });
+        expect(res.exitCode).toBe(0);
+        expect(res.stderr).toBe('');
+        const parsed = JSON.parse(res.stdout.trim());
+        expect(parsed.ok).toBe(true);
+        expect(parsed.data.dry_run).toBe(true);
+        expect(parsed.data.ops[0].type).toBe('create_rem');
+        expect(parsed.data.ops[0].payload.foo_bar).toBe(1);
+    });
+});

package/dist/apps/cli/tests/read-search.contract.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: read search --json', () => {
+    it('prints a single json envelope and keeps stderr empty on db error', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
+        const missingDb = path.join(tmpDir, 'missing-remnote.db');
+        try {
+            const res = await runCli(['--json', '--remnote-db', missingDb, 'read', 'search', '--query', 'hello']);
+            expect(res.exitCode).toBe(1);
+            expect(res.stderr).toBe('');
+            const parsed = JSON.parse(res.stdout.trim());
+            expect(parsed.ok).toBe(false);
+            expect(parsed.error.code).toBe('DB_UNAVAILABLE');
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/apps/cli/tests/ws-health.contract.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { startWebSocketBridge } from '../../../packages/mcp/src/ws/bridge.js';
+import { runCli } from './helpers/runCli.js';
+describe('cli contract: ws health --json', () => {
+    it('prints ok envelope and health data', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remnote-cli-test-'));
+        const queueDb = path.join(tmpDir, 'queue.sqlite');
+        const prevQueueDb = process.env.REMNOTE_QUEUE_DB;
+        process.env.REMNOTE_QUEUE_DB = queueDb;
+        const started = startWebSocketBridge({ enable: true, port: 0, path: '/ws' });
+        expect(started).toBeTruthy();
+        try {
+            const addr = started.wss.address();
+            const port = typeof addr === 'string' ? Number(addr) : addr.port;
+            const wsUrl = `ws://localhost:${port}/ws`;
+            const res = await runCli(['--json', '--ws-url', wsUrl, 'ws', 'health']);
+            expect(res.exitCode).toBe(0);
+            expect(res.stderr).toBe('');
+            const parsed = JSON.parse(res.stdout.trim());
+            expect(parsed.ok).toBe(true);
+            expect(parsed.data.url).toBe(wsUrl);
+            expect(typeof parsed.data.rtt_ms).toBe('number');
+        }
+        finally {
+            await started.close();
+            if (prevQueueDb === undefined)
+                delete process.env.REMNOTE_QUEUE_DB;
+            else
+                process.env.REMNOTE_QUEUE_DB = prevQueueDb;
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/apps/cli/vitest.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        environment: 'node',
+        include: ['tests/**/*.test.ts'],
+    },
+});