@adrive/cli 0.3.0 → 1.1.0

package/dist/lib/transcripts/cursor.js

@@ -0,0 +1,73 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, patchPaths, readText, toolSummary } from './util.js';
+// Cursor agent: ~/.cursor/projects/<path-slug>/agent-transcripts/<conv>/<conv>.jsonl
+// (or flat <conv>.jsonl). Lines are `{ role, message: { content: [...] } }`
+// with no timestamps and no cwd; sync falls back to the cwd the hook recorded
+// (see session-cwd.ts).
+const PATH_TOOLS = new Set(['Write', 'StrReplace', 'Delete']);
+const USER_QUERY_RE = /^\s*<user_query>\s*([\s\S]*?)\s*<\/user_query>\s*$/;
+async function readdirSafe(dir) {
+    try {
+        return await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}
+export const cursorSource = {
+    platform: 'cursor',
+    async enumerate({ home, since }) {
+        const root = join(home, '.cursor', 'projects');
+        const out = [];
+        for (const slug of await readdirSafe(root)) {
+            const dir = join(root, slug, 'agent-transcripts');
+            for (const name of await readdirSafe(dir)) {
+                const sessionId = name.replace(/\.jsonl$/, '');
+                const path = name.endsWith('.jsonl') ? join(dir, name) : join(dir, name, `${name}.jsonl`);
+                const mtime = await mtimeOf(path);
+                if (!mtime || (since && mtime <= since))
+                    continue;
+                out.push({ sessionId, path, mtime });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        const raw = await readText(entry.path);
+        if (raw === null)
+            return null;
+        const doc = new DocBuilder();
+        for (const obj of jsonLines(raw)) {
+            const role = asStr(obj.role);
+            if (role !== 'user' && role !== 'assistant')
+                continue;
+            const content = asObj(obj.message)?.content;
+            let text = typeof content === 'string' ? content : '';
+            const tools = [];
+            for (const part of Array.isArray(content) ? content : []) {
+                const p = asObj(part);
+                if (p?.type === 'text') {
+                    text += asStr(p.text) ?? '';
+                }
+                else if (p?.type === 'tool_use') {
+                    const name = asStr(p.name) ?? 'tool';
+                    if (name === 'ApplyPatch') {
+                        const input = typeof p.input === 'string' ? p.input : Object.values(asObj(p.input) ?? {}).filter((v) => typeof v === 'string').join('\n');
+                        const paths = patchPaths(input);
+                        for (const path of paths)
+                            doc.touch(path);
+                        tools.push(...(paths.length > 0 ? paths.map((path) => ({ name, path })) : [{ name }]));
+                    }
+                    else {
+                        const path = PATH_TOOLS.has(name) ? asStr(asObj(p.input)?.path) : undefined;
+                        doc.touch(path);
+                        tools.push(path ? { name, path } : { name, summary: toolSummary(p.input) });
+                    }
+                }
+            }
+            doc.addTurn(role, text.replace(USER_QUERY_RE, '$1'), undefined, tools);
+        }
+        return doc.build(entry);
+    },
+};

package/dist/lib/transcripts/gemini.js

@@ -0,0 +1,116 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { readSessionCwds } from '../session-cwd.js';
+import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, readText, toolSummary } from './util.js';
+// Gemini CLI: ~/.gemini/tmp/<project_hash>/chats/session-*.jsonl, one message
+// record per line plus `$set`/`$patch`/`$rewindTo` meta lines; legacy chats
+// are a single .json `{ sessionId, messages }`. The project hash is sha256 of
+// the project root, so cwd is recovered by hashing cwds the hook recorded.
+const CHAT_RE = /^session-.+\.jsonl?$/;
+// Both formats put the session id first, so the head is enough to name a chat
+// without parsing it; enumerate, parse and the hook must agree on this id.
+const HEAD_BYTES = 16 * 1024;
+const SESSION_ID_RE = /"sessionId"\s*:\s*"([^"\\]+)"/;
+function sessionIdOf(head, path) {
+    return SESSION_ID_RE.exec(head)?.[1] ?? (path.split(/[\\/]/).pop() ?? path).replace(/^session-/, '').replace(/\.jsonl?$/, '');
+}
+async function readHead(path) {
+    const handle = await fs.open(path, 'r');
+    try {
+        const buf = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buf, 0, HEAD_BYTES, 0);
+        return buf.subarray(0, bytesRead).toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+const FILE_TOOLS = new Set(['write_file', 'replace']);
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((p) => (typeof p === 'string' ? p : asStr(asObj(p)?.text) ?? '')).join('');
+}
+function addMessage(doc, msg) {
+    if (msg.type !== 'user' && msg.type !== 'gemini')
+        return;
+    const tools = [];
+    for (const raw of Array.isArray(msg.toolCalls) ? msg.toolCalls : []) {
+        const call = asObj(raw);
+        const name = asStr(call?.name) ?? 'tool';
+        const args = asObj(call?.args);
+        const path = FILE_TOOLS.has(name) ? asStr(args?.file_path) : undefined;
+        doc.touch(path);
+        tools.push(path ? { name, path } : { name, summary: toolSummary(args) });
+    }
+    doc.addTurn(msg.type === 'user' ? 'user' : 'assistant', messageText(msg.content), asStr(msg.timestamp), tools);
+}
+export const geminiSource = {
+    platform: 'gemini-cli',
+    async enumerate({ home, since, configDir }) {
+        const tmp = join(home, '.gemini', 'tmp');
+        let hashes;
+        try {
+            hashes = await fs.readdir(tmp);
+        }
+        catch {
+            return [];
+        }
+        const cwdByHash = new Map();
+        for (const cwd of Object.values(configDir ? await readSessionCwds(configDir) : {})) {
+            cwdByHash.set(createHash('sha256').update(cwd).digest('hex'), cwd);
+        }
+        const out = [];
+        for (const h of hashes) {
+            let files;
+            try {
+                files = await fs.readdir(join(tmp, h, 'chats'));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!CHAT_RE.test(f))
+                    continue;
+                const path = join(tmp, h, 'chats', f);
+                const mtime = await mtimeOf(path);
+                if (!mtime || (since && mtime <= since))
+                    continue;
+                const head = await readHead(path).catch(() => '');
+                out.push({ sessionId: sessionIdOf(head, path), path, mtime, cwd: cwdByHash.get(h) });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        const raw = await readText(entry.path);
+        if (raw === null)
+            return null;
+        const doc = new DocBuilder();
+        if (entry.path.endsWith('.json')) {
+            let legacy;
+            try {
+                legacy = asObj(JSON.parse(raw));
+            }
+            catch {
+                return null;
+            }
+            for (const m of Array.isArray(legacy?.messages) ? legacy.messages : []) {
+                const msg = asObj(m);
+                if (msg)
+                    addMessage(doc, msg);
+            }
+        }
+        else {
+            for (const line of jsonLines(raw)) {
+                if ('$set' in line || '$patch' in line || '$rewindTo' in line)
+                    continue;
+                addMessage(doc, line);
+            }
+        }
+        return doc.build({ ...entry, sessionId: sessionIdOf(Buffer.from(raw).subarray(0, HEAD_BYTES).toString('utf8'), entry.path) });
+    },
+};

package/dist/lib/transcripts/opencode.js

@@ -0,0 +1,95 @@
+import { execFile } from 'node:child_process';
+import { DocBuilder, asObj, asStr, patchPaths, toolSummary } from './util.js';
+const EXEC_TIMEOUT_MS = 15_000;
+const defaultExec = (args, cwd) => new Promise((resolve, reject) => {
+    execFile('opencode', [...args, '--pure'], { cwd, timeout: EXEC_TIMEOUT_MS, maxBuffer: 256 * 1024 * 1024, encoding: 'utf8' }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
+});
+function parseJson(out) {
+    const start = out.search(/[[{]/);
+    return start < 0 ? null : JSON.parse(out.slice(start));
+}
+function isoFromMs(ms) {
+    return typeof ms === 'number' ? new Date(ms).toISOString() : undefined;
+}
+function toolEntry(doc, name, input) {
+    if (name === 'write' || name === 'edit') {
+        const path = asStr(input?.filePath);
+        doc.touch(path);
+        return [path ? { name, path } : { name }];
+    }
+    if (name === 'patch' || name === 'apply_patch') {
+        const patch = Object.values(input ?? {}).filter((v) => typeof v === 'string').join('\n');
+        const paths = patchPaths(patch);
+        for (const p of paths)
+            doc.touch(p);
+        return paths.length > 0 ? paths.map((path) => ({ name, path })) : [{ name }];
+    }
+    return [{ name, summary: toolSummary(input) }];
+}
+export function createOpencodeSource(exec = defaultExec) {
+    return {
+        platform: 'opencode',
+        // shortcut: `opencode session list` only lists the project of `cwd`, so a
+        // sweep sees the sessions of the directory the hook fired in; reading
+        // OpenCode's storage directly would cover all projects.
+        async enumerate({ since, cwd }) {
+            let list;
+            try {
+                list = parseJson(await exec(['session', 'list', '--format', 'json'], cwd));
+            }
+            catch {
+                return [];
+            }
+            if (!Array.isArray(list))
+                return [];
+            const out = [];
+            for (const raw of list) {
+                const s = asObj(raw);
+                const id = asStr(s?.id);
+                const updated = s?.updated;
+                if (!id || typeof updated !== 'number')
+                    continue;
+                const mtime = new Date(updated);
+                if (since && mtime <= since)
+                    continue;
+                out.push({ sessionId: id, path: id, mtime, cwd: asStr(s?.directory) });
+            }
+            return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        },
+        async parseSession(entry) {
+            let data;
+            try {
+                data = asObj(parseJson(await exec(['export', entry.sessionId], entry.cwd)));
+            }
+            catch {
+                return null;
+            }
+            if (!data)
+                return null;
+            const info = asObj(data.info);
+            const doc = new DocBuilder();
+            for (const rawMsg of Array.isArray(data.messages) ? data.messages : []) {
+                const msg = asObj(rawMsg);
+                const mInfo = asObj(msg?.info);
+                const role = asStr(mInfo?.role) ?? 'assistant';
+                const ts = isoFromMs(asObj(mInfo?.time)?.created);
+                let text = '';
+                const tools = [];
+                for (const rawPart of Array.isArray(msg?.parts) ? msg.parts : []) {
+                    const part = asObj(rawPart);
+                    if (!part || part.synthetic)
+                        continue;
+                    if (part.type === 'text')
+                        text += asStr(part.text) ?? '';
+                    else if (part.type === 'tool')
+                        tools.push(...toolEntry(doc, asStr(part.tool) ?? 'tool', asObj(asObj(part.state)?.input)));
+                }
+                doc.addTurn(role, text, ts, tools);
+            }
+            const updated = isoFromMs(asObj(info?.time)?.updated);
+            const entryOut = updated ? { ...entry, mtime: new Date(updated) } : entry;
+            return doc.build(entryOut, asStr(info?.directory), asStr(info?.title));
+        },
+    };
+}
+export const opencodeSource = createOpencodeSource();

package/dist/lib/transcripts/types.js

@@ -0,0 +1,10 @@
+// Functional TranscriptSource interface — per eng-review decision E4.
+//
+// A source knows two things:
+// 1. `enumerate(opts)` — find candidate sessions on disk
+// 2. `parseSession(entry)` — turn one session into a TranscriptDoc
+//
+// Everything else (redact, encrypt, manifest, upload, run upsert) is
+// centralized in lib/sync.ts so the cross-cutting concerns can't drift
+// between harnesses.
+export {};

package/dist/lib/transcripts/util.js

@@ -0,0 +1,102 @@
+import { promises as fs } from 'node:fs';
+import { zstdDecompressSync } from 'node:zlib';
+const SUMMARY_CHARS = 160;
+const TITLE_CHARS = 120;
+// Only these input keys feed tool summaries, so file bodies (`content`,
+// `new_string`, ...) never reach a tool line.
+const SUMMARY_KEYS = ['command', 'cmd', 'file_path', 'filePath', 'notebook_path', 'path', 'pattern', 'query', 'url', 'description'];
+export function asObj(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+export function asStr(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+export async function readText(path) {
+    try {
+        const buf = await fs.readFile(path);
+        return (path.endsWith('.zst') ? zstdDecompressSync(buf) : buf).toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function jsonLines(raw) {
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = asObj(JSON.parse(line));
+            if (parsed)
+                out.push(parsed);
+        }
+        catch {
+            // Permissive: a torn last line or unknown record never fails a parse.
+        }
+    }
+    return out;
+}
+export function truncate(value, max) {
+    const flat = value.replace(/\s+/g, ' ').trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 3)}...`;
+}
+export function toolSummary(input) {
+    const obj = asObj(input);
+    if (!obj)
+        return typeof input === 'string' && input.trim() ? truncate(input.split('\n')[0], SUMMARY_CHARS) : undefined;
+    for (const key of SUMMARY_KEYS) {
+        const v = obj[key];
+        const s = Array.isArray(v) ? v.filter((x) => typeof x === 'string').join(' ') : asStr(v);
+        if (s && s.trim())
+            return truncate(s, SUMMARY_CHARS);
+    }
+    return undefined;
+}
+export function patchPaths(patch) {
+    const out = [];
+    for (const m of patch.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm))
+        out.push(m[1].trim());
+    return out;
+}
+export async function mtimeOf(path) {
+    try {
+        return (await fs.stat(path)).mtime;
+    }
+    catch {
+        return null;
+    }
+}
+export class DocBuilder {
+    turns = [];
+    files = new Set();
+    addTurn(role, text, ts, tools = []) {
+        const last = this.turns[this.turns.length - 1];
+        if (!text.trim()) {
+            if (tools.length === 0)
+                return;
+            // Harnesses log tool calls as separate records; fold them into the
+            // turn they belong to instead of emitting empty turns.
+            if (last && last.role === role) {
+                last.tools = [...(last.tools ?? []), ...tools];
+                return;
+            }
+        }
+        this.turns.push(tools.length > 0 ? { role, text, ts, tools } : { role, text, ts });
+    }
+    touch(path) {
+        if (path && path.trim())
+            this.files.add(path.trim());
+    }
+    build(entry, cwd, title) {
+        if (this.turns.length === 0)
+            return null;
+        const firstUser = this.turns.find((t) => t.role === 'user' && t.text.trim());
+        return {
+            entry,
+            turns: this.turns,
+            cwd: cwd ?? entry.cwd,
+            title: title?.trim() ? truncate(title, TITLE_CHARS) : firstUser ? truncate(firstUser.text, TITLE_CHARS) : undefined,
+            filesTouched: [...this.files],
+        };
+    }
+}

package/dist/lib/write-file.js

@@ -0,0 +1,55 @@
+import { constants, promises as fs } from 'node:fs';
+import { dirname } from 'node:path';
+export async function readTextIfExists(path) {
+    try {
+        return await fs.readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+// Throws on unparseable content so a merge never replaces a file it could not
+// read (JSONC with comments, a half-written file) with only our keys.
+export async function readJsonObject(path) {
+    const raw = await readTextIfExists(path);
+    if (raw === null)
+        return null;
+    if (!raw.trim())
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${path} is not plain JSON; left untouched`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${path} is not a JSON object; left untouched`);
+    }
+    return parsed;
+}
+export async function writeFileIfChanged(path, content, opts = {}) {
+    const current = await readTextIfExists(path);
+    if (current === content)
+        return 'unchanged';
+    await fs.mkdir(dirname(path), { recursive: true });
+    if (current !== null && opts.backup) {
+        // The first .bak is the user's pre-AgentDrive original; later runs must not overwrite it.
+        // 0600 because an original Codex config.toml can hold the API key init just removed.
+        try {
+            await fs.copyFile(path, `${path}.bak`, constants.COPYFILE_EXCL);
+            await fs.chmod(`${path}.bak`, 0o600);
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+    }
+    await fs.writeFile(path, content, 'utf8');
+    return current === null ? 'created' : 'updated';
+}
+export async function writeJsonIfChanged(path, value) {
+    return writeFileIfChanged(path, `${JSON.stringify(value, null, 2)}\n`, { backup: true });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adrive/cli",
-  "version": "0.3.0",
-  "description": "AgentDrive CLI — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph.",
+  "version": "1.1.0",
+  "description": "AgentDrive CLI — cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
@@ -37,18 +37,13 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc && node -e \"import('node:fs').then(fs => fs.chmodSync('dist/index.js', 0o755))\"",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
   "dependencies": {
     "chokidar": "^5.0.0",
     "commander": "^12.1.0",
     "kleur": "^4.1.5",
     "open": "^10.1.0",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "@adrive/mcp-server": "^1.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -57,6 +52,12 @@
     "vitest": "^2.1.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.15"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"import('node:fs').then(fs => fs.chmodSync('dist/index.js', 0o755))\"",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
-}
+}