@adrive/cli 0.2.1 → 1.0.0

package/dist/lib/keychain.js

@@ -0,0 +1,93 @@
+import { promises as fs } from 'node:fs';
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { hostname, userInfo } from 'node:os';
+import { dirname, join } from 'node:path';
+import { configDir } from './config.js';
+// AgentDrive lightweight keychain (v1, software-only).
+//
+// Goal: a random 256-bit data-encryption key (DEK), persisted across runs,
+// wrapped with a key-encrypting key (KEK) derived from
+//   scrypt(host || user || api_key, salt).
+//
+// This is stronger than "derive DEK directly from API key" because:
+//   - Rotating the API key doesn't change the DEK, so old ciphertext is
+//     still decryptable after rotation (with the same KEK derivation).
+//   - The DEK is random, not derivable from the API key alone.
+//   - host+user binding means a stolen API key cannot decrypt files
+//     without also having access to the user's home + machine identity.
+//
+// v2 will replace the KEK derivation with the OS keychain
+// (Keychain.app / libsecret / DPAPI). The interface stays the same.
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+const SALT_LENGTH = 16;
+const TAG_LENGTH = 16;
+const SCRYPT_N = 1 << 14;
+const SCRYPT_MAXMEM = 64 * 1024 * 1024;
+const FILE_VERSION = 1;
+export function keychainPath(env = process.env) {
+    return join(configDir(env), 'keychain.bin');
+}
+function deriveKek(apiKey, salt) {
+    // Bind to the machine + user. A stolen API key alone won't unwrap the DEK.
+    const ident = `${hostname()}|${userInfo().username}|${apiKey}`;
+    return scryptSync(ident, salt, KEY_LENGTH, { N: SCRYPT_N, maxmem: SCRYPT_MAXMEM });
+}
+async function readBlob(path) {
+    try {
+        const raw = await fs.readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.v !== FILE_VERSION)
+            return null;
+        return parsed;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return null;
+        return null;
+    }
+}
+async function writeBlob(path, blob) {
+    await fs.mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await fs.writeFile(path, JSON.stringify(blob), { encoding: 'utf8', mode: 0o600 });
+}
+export async function loadDek(apiKey, path = keychainPath()) {
+    const existing = await readBlob(path);
+    if (existing) {
+        const salt = Buffer.from(existing.salt, 'base64');
+        const iv = Buffer.from(existing.iv, 'base64');
+        const tag = Buffer.from(existing.tag, 'base64');
+        const ct = Buffer.from(existing.ct, 'base64');
+        const kek = deriveKek(apiKey, salt);
+        const dec = createDecipheriv('aes-256-gcm', kek, iv);
+        dec.setAuthTag(tag);
+        return Buffer.concat([dec.update(ct), dec.final()]);
+    }
+    // First use: create a fresh DEK and persist wrapped.
+    const dek = randomBytes(KEY_LENGTH);
+    const salt = randomBytes(SALT_LENGTH);
+    const iv = randomBytes(IV_LENGTH);
+    const kek = deriveKek(apiKey, salt);
+    const enc = createCipheriv('aes-256-gcm', kek, iv);
+    const ct = Buffer.concat([enc.update(dek), enc.final()]);
+    const tag = enc.getAuthTag();
+    if (tag.length !== TAG_LENGTH)
+        throw new Error('Unexpected GCM tag length');
+    await writeBlob(path, {
+        v: FILE_VERSION,
+        salt: salt.toString('base64'),
+        iv: iv.toString('base64'),
+        tag: tag.toString('base64'),
+        ct: ct.toString('base64'),
+    });
+    return dek;
+}
+export async function purgeKeychain(path = keychainPath()) {
+    try {
+        await fs.unlink(path);
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/lib/redactor.js

@@ -0,0 +1,69 @@
+// Secret redactor. Runs on every payload before capture features upload
+// content. Patterns are intentionally conservative — false positives are
+// tagged and replaced with a safe marker; false negatives are the risk we
+// optimize against.
+//
+// IMPORTANT: redaction is best-effort, not a security boundary. It is one
+// layer in a defense-in-depth stack: .adriveignore for path-level deny,
+// redactor for content-level scrub, optional client-side encryption for
+// confidentiality.
+// Order matters: more specific patterns first so they win over the generic
+// high-entropy fallback.
+const PATTERNS = [
+    // Provider-specific keys
+    { kind: 'aws-access-key-id', re: /\bAKIA[0-9A-Z]{16}\b/g, marker: () => '[redacted:aws-access-key-id]' },
+    { kind: 'aws-secret', re: /\b(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY)[\s:=]+['"]?[A-Za-z0-9/+=]{40}['"]?/g, marker: () => '[redacted:aws-secret]' },
+    { kind: 'gcp-service-account', re: /"private_key":\s*"-----BEGIN PRIVATE KEY-----[\s\S]*?-----END PRIVATE KEY-----[^"]*"/g, marker: () => '"private_key":"[redacted:gcp-service-account]"' },
+    { kind: 'stripe-secret', re: /\bsk_(?:live|test)_[A-Za-z0-9]{16,99}\b/g, marker: () => '[redacted:stripe-secret]' },
+    { kind: 'stripe-restricted', re: /\brk_(?:live|test)_[A-Za-z0-9]{16,99}\b/g, marker: () => '[redacted:stripe-restricted]' },
+    { kind: 'github-token', re: /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g, marker: () => '[redacted:github-token]' },
+    { kind: 'github-fine-grained', re: /\bgithub_pat_[A-Za-z0-9_]{82}\b/g, marker: () => '[redacted:github-fine-grained]' },
+    { kind: 'anthropic-key', re: /\bsk-ant-[A-Za-z0-9_-]{20,}/g, marker: () => '[redacted:anthropic-key]' },
+    { kind: 'openai-key', re: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}/g, marker: () => '[redacted:openai-key]' },
+    { kind: 'agentdrive-key', re: /\bagentdrive_live_[A-Za-z0-9]{16,}/g, marker: () => '[redacted:agentdrive-key]' },
+    { kind: 'slack-bot-token', re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, marker: () => '[redacted:slack-token]' },
+    { kind: 'jwt', re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, marker: () => '[redacted:jwt]' },
+    // Private keys (PEM-style blocks). Match the whole block.
+    { kind: 'private-key-pem', re: /-----BEGIN (?:RSA |OPENSSH |EC |DSA |ENCRYPTED |PRIVATE)?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |OPENSSH |EC |DSA |ENCRYPTED |PRIVATE)?PRIVATE KEY-----/g, marker: () => '[redacted:private-key]' },
+    // Generic high-entropy assignment forms: VAR=secret-looking-string
+    { kind: 'env-secret', re: /\b(?:[A-Z][A-Z0-9_]*_(?:KEY|SECRET|TOKEN|PASS(?:WORD)?|PWD|CREDENTIAL))\s*[:=]\s*['"]?([A-Za-z0-9+/_=-]{16,})['"]?/g, marker: (m) => m.replace(/(.*?[:=]\s*['"]?)([A-Za-z0-9+/_=-]{16,})(['"]?)/, '$1[redacted:env-secret]$3') },
+];
+function offsetToLineCol(text, offset) {
+    let line = 1;
+    let lastNewline = -1;
+    for (let i = 0; i < offset; i++) {
+        if (text.charCodeAt(i) === 10) {
+            line++;
+            lastNewline = i;
+        }
+    }
+    return { line, column: offset - lastNewline };
+}
+export function redact(input) {
+    let out = input;
+    const hits = [];
+    for (const p of PATTERNS) {
+        out = out.replace(p.re, (match, ..._args) => {
+            // Locate this match in the *original* input for line/col reporting.
+            // Using the original gives stable coordinates the user can verify.
+            const idx = input.indexOf(match);
+            if (idx >= 0) {
+                const { line, column } = offsetToLineCol(input, idx);
+                hits.push({ kind: p.kind, line, column, length: match.length });
+            }
+            return p.marker(match);
+        });
+    }
+    return { redacted: out, hits };
+}
+export function summarizeHits(hits) {
+    if (hits.length === 0)
+        return 'no secrets detected';
+    const counts = {};
+    for (const h of hits)
+        counts[h.kind] = (counts[h.kind] ?? 0) + 1;
+    return Object.entries(counts)
+        .sort(([, a], [, b]) => b - a)
+        .map(([k, n]) => `${k}×${n}`)
+        .join(', ');
+}

package/dist/lib/skill.js

@@ -0,0 +1,117 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+// Source-of-truth for the Claude Code skill file. The shell installer
+// (apps/installer/install.sh) inlines this content too — keep them in sync
+// when SKILL_MARKDOWN changes.
+export const SKILL_MARKDOWN = `---
+name: agentdrive
+description: |
+  Persistent cross-platform workspace for AI agents. Use this skill when the
+  user wants to share files between agent sessions, retrieve prior context,
+  log a run, or work with the AgentDrive MCP server but those tools are not
+  available. Calls the local \`adrive\` CLI as a fallback.
+---
+
+# AgentDrive — shared artifact workspace for multi-agent workflows
+
+If the \`drive_*\` MCP tools are wired, prefer them. Use the \`adrive\` CLI when
+the MCP server is not available or for shell-level workflows.
+
+## When to use this skill
+
+Trigger on any of these patterns:
+
+- "Share this with Codex / Cursor / my other agent"
+- "What did the last session produce?"
+- "What did Codex / Cursor / Claude work on?"
+- "Pull context for this task"
+- "Save this artifact so the next agent can find it"
+- "Log this run" / "remember what I just did"
+- "Search my workspace for X"
+- The user mentions a workspace, share link, or cross-agent handoff
+
+## Commands
+
+\`\`\`
+adrive context "<task>" [--limit N]                  # auto-pull relevant artifacts
+adrive search "<query>" [--top-k N]                  # semantic search
+adrive push <file> [--workspace ws] [--remote-path]  # write artifact
+adrive pull <ws-id>/<path> [-o out]                  # read artifact
+adrive run-log "<task>" --status success             # log a run
+adrive ls                                            # list workspaces
+adrive whoami                                        # show principal
+\`\`\`
+
+\`adrive\` reads its config from \`~/.config/agentdrive/config.json\` so the user
+is already authenticated. If the user is NOT authenticated, prompt them to
+run \`adrive init\` first instead of guessing.
+
+## Output handling
+
+\`adrive context\` returns each artifact with an \`attribution\` block. When
+you cite the artifact to the user, mention *why* it surfaced
+(\`reasons: ["high semantic match", "still fresh"]\`). When the artifact has a
+\`last_run\` block, mention the prior run's task so the user sees the
+narrative thread.
+
+## Privacy
+
+Respect \`adrive privacy\` settings. If the user has "Private workspace" on,
+written content is encrypted client-side; server stores only ciphertext.
+`;
+// Marker that auto-context.ts writes into CLAUDE.md. If present, the user
+// already has the MCP preflight wired and the skill would double-fire.
+const AUTO_CONTEXT_MARKER = '<!-- agentdrive:auto-context:begin -->';
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installClaudeSkill(opts = {}) {
+    const home = opts.home ?? homedir();
+    const claudeDir = join(home, '.claude');
+    const skillPath = join(claudeDir, 'skills', 'agentdrive', 'SKILL.md');
+    if (!(await fileExists(claudeDir))) {
+        return { path: skillPath, action: 'skipped-no-claude' };
+    }
+    if (!opts.force) {
+        const claudeMdPath = join(claudeDir, 'CLAUDE.md');
+        if (await fileExists(claudeMdPath)) {
+            const claudeMd = await fs.readFile(claudeMdPath, 'utf8');
+            if (claudeMd.includes(AUTO_CONTEXT_MARKER)) {
+                return { path: skillPath, action: 'skipped-preflight-installed' };
+            }
+        }
+    }
+    const existed = await fileExists(skillPath);
+    if (existed) {
+        const current = await fs.readFile(skillPath, 'utf8');
+        if (current === SKILL_MARKDOWN) {
+            return { path: skillPath, action: 'unchanged' };
+        }
+        await fs.writeFile(skillPath, SKILL_MARKDOWN, 'utf8');
+        return { path: skillPath, action: 'updated' };
+    }
+    await fs.mkdir(dirname(skillPath), { recursive: true });
+    await fs.writeFile(skillPath, SKILL_MARKDOWN, 'utf8');
+    return { path: skillPath, action: 'created' };
+}
+export function describeSkillAction(action) {
+    switch (action) {
+        case 'created':
+            return 'created';
+        case 'updated':
+            return 'updated';
+        case 'unchanged':
+            return 'already up to date';
+        case 'skipped-no-claude':
+            return 'skipped (no ~/.claude directory; Claude Code not installed)';
+        case 'skipped-preflight-installed':
+            return 'skipped (auto-context preflight is already in CLAUDE.md — use --force to override)';
+    }
+}

package/dist/lib/transcripts/claude.js

@@ -0,0 +1,112 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+// Claude Code session format:
+//   ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
+//
+// Each line is a JSON object. We care about lines where
+//   type === 'user' or 'assistant'
+// with a nested `message: { role, content }`. Content is a string OR
+// an array of message parts. Tool calls and intermediate states are
+// skipped — agents already see the natural-language turns.
+export const claudeSource = {
+    platform: 'claude-code',
+    async enumerate({ home, since }) {
+        const projectsDir = join(home, '.claude', 'projects');
+        let projects;
+        try {
+            projects = await fs.readdir(projectsDir);
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const p of projects) {
+            const pdir = join(projectsDir, p);
+            let files;
+            try {
+                files = await fs.readdir(pdir);
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!f.endsWith('.jsonl'))
+                    continue;
+                const full = join(pdir, f);
+                let stat;
+                try {
+                    stat = await fs.stat(full);
+                }
+                catch {
+                    continue;
+                }
+                if (since && stat.mtime <= since)
+                    continue;
+                const sessionId = f.replace(/\.jsonl$/, '');
+                out.push({
+                    manifestKey: `claude-code:${sessionId}`,
+                    sessionId,
+                    path: full,
+                    mtime: stat.mtime,
+                    label: p,
+                });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        let raw;
+        try {
+            raw = await fs.readFile(entry.path, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const turns = [];
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const turn = extractTurn(line);
+            if (turn)
+                turns.push(turn);
+        }
+        if (turns.length === 0)
+            return null;
+        return { entry, turns };
+    },
+};
+export function extractTurn(line) {
+    let obj;
+    try {
+        obj = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = obj.type ?? '';
+    const ts = obj.timestamp ?? undefined;
+    if (type === 'user' || type === 'assistant') {
+        const msg = obj.message;
+        if (!msg)
+            return null;
+        const role = msg.role ?? type;
+        const content = msg.content;
+        let text = '';
+        if (typeof content === 'string') {
+            text = content;
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if (typeof part === 'string')
+                    text += part;
+                else if (part && typeof part === 'object' && 'text' in part) {
+                    text += String(part.text);
+                }
+            }
+        }
+        if (!text.trim())
+            return null;
+        return { role, text, ts };
+    }
+    return null;
+}

package/dist/lib/transcripts/codex.js

@@ -0,0 +1,168 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+// OpenAI Codex CLI session format:
+//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ISO-date>-<session-id>.jsonl
+//
+// The first line is a `session_meta` record carrying the session id, cli
+// version, cwd, and base instructions. Subsequent lines carry the turn
+// stream as `{ timestamp, type, payload }`. We extract user + assistant
+// text from `type: 'turn'` records (with `payload.role` + `payload.content`)
+// and from `type: 'response_item'` records (with `payload.type: 'message'`
+// and `payload.content[*].text`). Older Codex versions vary slightly; we
+// only require that text fields exist where we expect them and drop the
+// rest. Tool calls / reasoning / system events are skipped — agents only
+// need the natural-language turns.
+//
+// Per Codex finding #11, the on-disk format may shift between CLI versions.
+// The parser stays permissive: unknown record types are silently ignored
+// rather than crashing the ingest.
+const SESSION_ID_RE = /^rollout-.+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+async function walkRolloutFiles(root) {
+    // Walks the YYYY/MM/DD tree depth-first. Tolerant of missing dirs.
+    const acc = [];
+    let years;
+    try {
+        years = await fs.readdir(root);
+    }
+    catch {
+        return [];
+    }
+    for (const y of years) {
+        const ydir = join(root, y);
+        let months;
+        try {
+            months = await fs.readdir(ydir);
+        }
+        catch {
+            continue;
+        }
+        for (const m of months) {
+            const mdir = join(ydir, m);
+            let days;
+            try {
+                days = await fs.readdir(mdir);
+            }
+            catch {
+                continue;
+            }
+            for (const d of days) {
+                const ddir = join(mdir, d);
+                let files;
+                try {
+                    files = await fs.readdir(ddir);
+                }
+                catch {
+                    continue;
+                }
+                for (const f of files) {
+                    if (f.startsWith('rollout-') && f.endsWith('.jsonl')) {
+                        acc.push(join(ddir, f));
+                    }
+                }
+            }
+        }
+    }
+    return acc;
+}
+export const codexSource = {
+    platform: 'codex',
+    async enumerate({ home, since }) {
+        const root = join(home, '.codex', 'sessions');
+        const files = await walkRolloutFiles(root);
+        const out = [];
+        for (const full of files) {
+            let stat;
+            try {
+                stat = await fs.stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (since && stat.mtime <= since)
+                continue;
+            const base = full.split('/').pop() ?? full;
+            const idMatch = base.match(SESSION_ID_RE);
+            const sessionId = idMatch ? idMatch[1] : base.replace(/\.jsonl$/, '');
+            // `label` is best-effort — fill from the cwd in session_meta on parse.
+            out.push({
+                manifestKey: `codex:${sessionId}`,
+                sessionId,
+                path: full,
+                mtime: stat.mtime,
+                label: 'codex session',
+            });
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        let raw;
+        try {
+            raw = await fs.readFile(entry.path, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const turns = [];
+        let cwd;
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const type = obj.type ?? '';
+            const ts = obj.timestamp ?? undefined;
+            const payload = (obj.payload ?? {});
+            if (type === 'session_meta') {
+                const c = payload.cwd;
+                if (typeof c === 'string')
+                    cwd = c;
+                continue;
+            }
+            // Two known shapes for natural-language turns:
+            //   1. payload.role + payload.content (string or array)
+            //   2. payload.type === 'message' with payload.content[*].text
+            let role;
+            let text = '';
+            if (typeof payload.role === 'string' && payload.content !== undefined) {
+                role = payload.role;
+                const c = payload.content;
+                if (typeof c === 'string')
+                    text = c;
+                else if (Array.isArray(c)) {
+                    for (const part of c) {
+                        if (typeof part === 'string')
+                            text += part;
+                        else if (part && typeof part === 'object' && 'text' in part) {
+                            text += String(part.text);
+                        }
+                    }
+                }
+            }
+            else if (payload.type === 'message') {
+                const innerRole = payload.role;
+                if (typeof innerRole === 'string')
+                    role = innerRole;
+                const c = payload.content;
+                if (Array.isArray(c)) {
+                    for (const part of c) {
+                        if (part && typeof part === 'object' && 'text' in part) {
+                            text += String(part.text);
+                        }
+                    }
+                }
+            }
+            if (role && text.trim()) {
+                turns.push({ role, text, ts });
+            }
+        }
+        if (turns.length === 0)
+            return null;
+        const labeled = cwd ? { ...entry, label: cwd } : entry;
+        return { entry: labeled, turns };
+    },
+};

package/dist/lib/transcripts/cursor.js

@@ -0,0 +1,23 @@
+// Cursor stores chat history in a per-workspace SQLite database at
+//   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/state.vscdb
+// (macOS) or the analogous path on Linux. Reading it requires `node:sqlite`
+// (Node 22.5+) or `better-sqlite3`. The CLI's `engines.node` is currently
+// `>=20` so neither is available out of the box.
+//
+// Per CEO plan D3 + Codex tension T3 + finding #11, this surface is brittle
+// reverse-engineering and intentionally kept narrow. The full implementation
+// lands in Phase 2.5 (tracked in TODOS.md). For now this source exposes a
+// clear error so users hit explicit "not yet" rather than silent zero hits.
+const CURSOR_NOT_IMPLEMENTED_MESSAGE = 'Cursor transcript ingestion is not yet available. Reading Cursor SQLite ' +
+    "history requires Node 22.5+ (node:sqlite) or a native dependency. " +
+    'Tracking under Phase 2.5 of the v1 plan.';
+export const cursorSource = {
+    platform: 'cursor',
+    async enumerate(_opts) {
+        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    },
+    async parseSession(_entry) {
+        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    },
+};
+export { CURSOR_NOT_IMPLEMENTED_MESSAGE };