@hcu-lab.me/mcp-device 1.0.10 → 1.0.12

package/dist/log-palace/cli.js

@@ -0,0 +1,89 @@
+import { LogPalace } from './store.js';
+const usage = [
+    'mcp-device logs discover                         # register existing Pi, Codex, MCP log paths',
+    'mcp-device logs add <file-or-dir> [--format auto|pi|codex|mcp|text]',
+    'mcp-device logs sources                          # show registered inputs and index size',
+    'mcp-device logs index [--max-files N] [--max-bytes N]',
+    'mcp-device logs search --query "words" [--limit N]',
+    'mcp-device logs read --ref <ref> [--max-bytes N] [--from-byte N]',
+    'mcp-device logs graph --ref <ref> [--limit N]',
+].join('\n');
+function integer(value, def) {
+    if (value === undefined)
+        return def;
+    if (!/^\d+$/.test(value))
+        throw new Error('BUDGET_EXCEEDED');
+    const n = Number(value);
+    if (!Number.isSafeInteger(n))
+        throw new Error('BUDGET_EXCEEDED');
+    return n;
+}
+/** No network, model call, live capture, consent gate or implicit log discovery. */
+export function runLogPalaceCli(argv, stateDir) {
+    if (!argv.length || ['help', '--help', '-h'].includes(argv[0]))
+        return { exitCode: 0, stdout: usage + '\n', stderr: '' };
+    let db;
+    try {
+        const [command, ...args] = argv;
+        const opts = new Map();
+        const positionals = [];
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg === '--json')
+                continue;
+            if (arg.startsWith('--')) {
+                if (!['--format', '--max-files', '--max-bytes', '--query', '--ref', '--limit', '--from-byte'].includes(arg) || opts.has(arg))
+                    throw new Error('ACTION_UNSUPPORTED');
+                if (i + 1 >= args.length)
+                    throw new Error('ACTION_UNSUPPORTED');
+                opts.set(arg, args[++i]);
+            }
+            else
+                positionals.push(arg);
+        }
+        const allowed = {
+            discover: [], add: ['--format'], sources: [], index: ['--max-files', '--max-bytes'],
+            search: ['--query', '--limit'], read: ['--ref', '--max-bytes', '--from-byte'], graph: ['--ref', '--limit'],
+        };
+        if (!(command in allowed) || [...opts.keys()].some(f => !allowed[command].includes(f)))
+            throw new Error('ACTION_UNSUPPORTED');
+        db = new LogPalace(stateDir);
+        let result;
+        if (command === 'discover' || command === 'sources' || command === 'index') {
+            if (positionals.length)
+                throw new Error('ACTION_UNSUPPORTED');
+            if (command === 'discover')
+                result = db.discover();
+            else if (command === 'sources')
+                result = db.sources();
+            else
+                result = db.index({ maxFiles: integer(opts.get('--max-files'), 200), maxBytes: integer(opts.get('--max-bytes'), 32 * 1024 * 1024) });
+        }
+        else if (command === 'add') {
+            if (positionals.length !== 1)
+                throw new Error('ACTION_UNSUPPORTED');
+            result = db.add(positionals[0], (opts.get('--format') ?? 'auto'));
+        }
+        else if (command === 'search') {
+            const query = opts.get('--query') ?? positionals[0];
+            if (positionals.length > 1 || !query)
+                throw new Error('QUERY_REQUIRED');
+            result = db.search(query, integer(opts.get('--limit'), 5));
+        }
+        else {
+            const ref = opts.get('--ref') ?? positionals[0];
+            if (positionals.length > 1 || !ref)
+                throw new Error('INVALID_REF');
+            result = command === 'read' ? db.read(ref, integer(opts.get('--max-bytes'), 8192), opts.has('--from-byte') ? integer(opts.get('--from-byte'), 0) : undefined) : db.graph(ref, integer(opts.get('--limit'), 12));
+        }
+        return { exitCode: 0, stdout: JSON.stringify({ ok: true, result }) + '\n', stderr: '' };
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : 'INTERNAL_ERROR';
+        const code = /^[A-Z_]+$/.test(raw) ? raw : 'SOURCE_UNAVAILABLE';
+        return { exitCode: 1, stdout: '', stderr: JSON.stringify({ ok: false, error: code }) + '\n' };
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/log-palace/formats.d.ts

@@ -0,0 +1,26 @@
+/** Adapters for existing, user-accessible log files. No capture/observer dependency. */
+export type Format = 'auto' | 'pi' | 'codex' | 'mcp' | 'text';
+export type ResolvedFormat = Exclude<Format, 'auto'>;
+export type Context = {
+    session: string | null;
+    turn: string | null;
+    cwd: string | null;
+};
+export interface Item {
+    part: number;
+    kind: string;
+    timestamp: string | null;
+    session: string | null;
+    turn: string | null;
+    callId: string | null;
+    tool: string | null;
+    filePath: string | null;
+    outcome: string | null;
+    searchText: string;
+    preview: string;
+}
+export declare function detect(line: string): ResolvedFormat;
+export declare function parse(format: ResolvedFormat, line: string, before: Context): {
+    items: Item[];
+    context: Context;
+};

package/dist/log-palace/formats.js

@@ -0,0 +1,126 @@
+const obj = (x) => x && typeof x === 'object' && !Array.isArray(x) ? x : null;
+const str = (x) => typeof x === 'string' && x.length ? x : null;
+function render(x) { if (typeof x === 'string')
+    return x; try {
+    return JSON.stringify(x) ?? '';
+}
+catch {
+    return '';
+} }
+function textParts(x) {
+    if (typeof x === 'string')
+        return x;
+    if (!Array.isArray(x))
+        return render(x);
+    return x.map(v => { const p = obj(v); return p ? (str(p.text) ?? str(p.input_text) ?? '') : render(v); }).filter(Boolean).join('\n');
+}
+function sourceFile(a) {
+    const x = typeof a === 'string' ? (() => { try {
+        return obj(JSON.parse(a));
+    }
+    catch {
+        return null;
+    } })() : obj(a);
+    return x ? (str(x.path) ?? str(x.file_path) ?? str(x.filePath) ?? str(x.filename)) : null;
+}
+export function detect(line) {
+    let x;
+    try {
+        x = obj(JSON.parse(line));
+    }
+    catch {
+        return 'text';
+    }
+    if (!x)
+        return 'text';
+    if ((x.type === 'session' && str(x.id) && 'cwd' in x) || (x.type === 'message' && obj(x.message)?.role))
+        return 'pi';
+    if (['session_meta', 'response_item', 'turn_context', 'event_msg'].includes(String(x.type)))
+        return 'codex';
+    if (str(x.toolName) && ('arguments' in x || 'output' in x))
+        return 'mcp';
+    return 'text';
+}
+export function parse(format, line, before) {
+    let x = null;
+    try {
+        x = obj(JSON.parse(line));
+    }
+    catch { }
+    let session = before.session, turn = before.turn, cwd = before.cwd;
+    const items = [];
+    const add = (part, kind, body, o = {}) => {
+        if (!body.trim())
+            return;
+        const searchText = body;
+        items.push({ part, kind, searchText, preview: body.slice(0, 4096).replace(/\s+/g, ' ').trim().slice(0, 135),
+            timestamp: o.timestamp ?? str(x?.timestamp), session: o.session ?? session, turn: o.turn ?? turn,
+            callId: o.callId ?? null, tool: o.tool ?? null, filePath: o.filePath ?? null, outcome: o.outcome ?? null });
+    };
+    if (format === 'pi' && x) {
+        if (x.type === 'session') {
+            session = str(x.id) ?? session;
+            cwd = str(x.cwd) ?? cwd;
+            add(-1, 'session', 'Pi session ' + (session ?? '') + ' ' + (cwd ?? ''));
+        }
+        else if (x.type === 'message') {
+            const m = obj(x.message), role = str(m?.role) ?? 'message', parts = Array.isArray(m?.content) ? m.content : [];
+            if (role === 'assistant') {
+                for (let i = 0; i < parts.length; i++) {
+                    const p = obj(parts[i]);
+                    if (p?.type === 'toolCall') {
+                        const tool = str(p.name), args = p.arguments;
+                        add(i, 'tool_call', (tool ?? '') + ' ' + render(args), { tool, callId: str(p.id), filePath: sourceFile(args) });
+                    }
+                    else if (p?.type === 'text' && str(p.text))
+                        add(i, 'assistant', str(p.text));
+                }
+            }
+            else if (role === 'toolResult') {
+                const tool = str(m?.toolName);
+                add(-1, 'tool_result', (tool ?? '') + ' ' + textParts(m?.content), { tool, callId: str(m?.toolCallId), outcome: m?.isError ? 'error' : 'result' });
+            }
+            else
+                add(-1, role, textParts(m?.content) || render(m?.content));
+        }
+        else if (x.type === 'session_info')
+            add(-1, 'session_info', str(x.name) ?? '');
+    }
+    else if (format === 'codex' && x) {
+        const p = obj(x.payload), type = str(p?.type);
+        if (x.type === 'session_meta') {
+            session = str(p?.id) ?? session;
+            cwd = str(p?.cwd) ?? cwd;
+            add(-1, 'session', 'Codex session ' + (session ?? '') + ' ' + (cwd ?? ''));
+        }
+        else if (x.type === 'turn_context') {
+            turn = str(p?.turn_id) ?? turn;
+            cwd = str(p?.cwd) ?? cwd;
+        }
+        else if (x.type === 'event_msg' && type === 'task_started')
+            turn = str(p?.turn_id) ?? turn;
+        else if (x.type === 'response_item' && (type === 'function_call' || type === 'custom_tool_call')) {
+            const tool = str(p?.name), args = p?.arguments ?? p?.input;
+            add(-1, 'tool_call', (tool ?? '') + ' ' + render(args), { tool, callId: str(p?.call_id), filePath: sourceFile(args) });
+        }
+        else if (x.type === 'response_item' && (type === 'function_call_output' || type === 'custom_tool_call_output')) {
+            add(-1, 'tool_result', render(p?.output), { callId: str(p?.call_id), outcome: 'result' });
+        }
+        else if (x.type === 'response_item' && type === 'message')
+            add(-1, str(p?.role) ?? 'message', textParts(p?.content));
+        else if (x.type === 'event_msg' && (type === 'user_message' || type === 'agent_message'))
+            add(-1, type, str(p?.message) ?? '');
+        if (x.type === 'event_msg' && type === 'task_complete')
+            turn = null;
+    }
+    else if (format === 'mcp' && x) {
+        const tool = str(x.toolName) ?? str(x.tool), args = x.arguments ?? x.args;
+        add(-1, 'tool_call_result', (tool ?? '') + ' ' + render(args) + ' ' + render(x.output ?? x.result ?? x.error), {
+            tool, filePath: sourceFile(args), callId: str(x.call_id), outcome: x.error ? 'error' : 'result',
+            session: str(x.session_id) ?? session
+        });
+    }
+    else
+        add(-1, 'text', line);
+    return { items, context: { session, turn, cwd } };
+}

package/dist/log-palace/store.d.ts

@@ -0,0 +1,129 @@
+import { DatabaseSync } from 'node:sqlite';
+import { type Format } from './formats.js';
+type Row = Record<string, unknown>;
+export declare class LogPalace {
+    readonly db: DatabaseSync;
+    constructor(stateDir?: string);
+    close(): void;
+    private atomic;
+    add(sourcePath: string, format?: Format): {
+        path: string;
+        format: Format;
+        kind: string;
+    };
+    discover(): {
+        added: {
+            path: string;
+            format: Format;
+            kind: string;
+        }[];
+    };
+    sources(): {
+        sources: Record<string, import("node:sqlite").Value>[];
+        indexed_files: number;
+        indexed_records: number;
+    };
+    /**
+     * Read-only bounded feed for evidence consumers. It does not index or verify source bytes.
+     * Consumers must call read(ref) before deriving knowledge; the stored hash is a locator,
+     * not proof of truth. Resume by opaque ref cursor; restart a completed pass to see inserts.
+     */
+    observations(options?: {
+        cursor?: string;
+        limit?: number;
+        maxBytes?: number;
+    }): {
+        items: Row[];
+        nextCursor: string | null;
+        complete: boolean;
+    };
+    private scanPage;
+    private fingerprint;
+    private contentHash;
+    private indexSearchText;
+    private reset;
+    private formatFor;
+    private indexFile;
+    index(options?: {
+        maxFiles?: number;
+        maxBytes?: number;
+    }): {
+        files: number;
+        records: number;
+        lines: number;
+        bytes: number;
+        reset: number;
+        stalled: number;
+        partial: number;
+        errors: string[];
+        more_files: boolean;
+        total_records: number;
+    };
+    private record;
+    private validUtf8;
+    private selectedPartSpan;
+    /** Locate FTS terms in original UTF-8 source bytes, never in synthetic search text. */
+    private sourceHit;
+    search(query: string, limit?: number): {
+        query: string;
+        items: {
+            hit_unit: string;
+            hit_offset: number | null;
+            hit_term: string | null;
+            anchor_status: string;
+        }[];
+        count: number;
+    };
+    read(ref: string, maxBytes?: number, fromByte?: number): {
+        ref: string;
+        source: unknown;
+        kind: unknown;
+        tool: unknown;
+        session: unknown;
+        turn: unknown;
+        call_id: unknown;
+        offset: unknown;
+        bytes: unknown;
+        text: string;
+        view: string;
+        range_start: number;
+        range_end: number;
+        next_offset: null;
+        resumable: boolean;
+        truncated: boolean;
+    } | {
+        ref: string;
+        source: unknown;
+        kind: unknown;
+        tool: unknown;
+        session: unknown;
+        turn: unknown;
+        call_id: unknown;
+        offset: unknown;
+        bytes: unknown;
+        text: string;
+        view: string;
+        range_start: number;
+        range_end: number;
+        next_offset: number | null;
+        truncated: boolean;
+        resumable?: undefined;
+    };
+    graph(ref: string, limit?: number): {
+        ref: string;
+        kind: unknown;
+        session: unknown;
+        call_id: unknown;
+        neighbors: {
+            ref: string;
+            relation: string;
+            basis: string;
+            kind: unknown;
+            tool: unknown;
+            preview: unknown;
+        }[];
+        count: number;
+        note: string;
+    };
+}
+export {};