@adrive/cli 0.2.1 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @adrive/cli
 
-The `adrive` binary — a thin CLI for [AgentDrive](https://agentdrive.sh), the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph.
+The `adrive` binary — a thin CLI for [AgentDrive](https://agentdrive.sh), the cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.
 
 ## Install
 

package/dist/commands/context.js

@@ -1,12 +1,22 @@
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
 import { requireLogin } from '../lib/config.js';
+import { installClaudeSkill, describeSkillAction } from '../lib/skill.js';
 function truncate(s, n) {
     if (!s)
         return '';
     return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
 }
 export async function cmdContext(task, opts = {}) {
+    if (opts.installSkill) {
+        const result = await installClaudeSkill({ force: opts.force });
+        process.stdout.write(`Claude skill ${describeSkillAction(result.action)}: ${kleur.dim(result.path)}\n`);
+        return;
+    }
+    if (!task) {
+        process.stderr.write('error: missing required argument <task>\n');
+        process.exit(1);
+    }
     const cfg = await requireLogin();
     const client = new CliApiClient({
         baseUrl: cfg.api_url,
@@ -25,8 +35,15 @@ export async function cmdContext(task, opts = {}) {
         return;
     }
     for (const a of res.artifacts) {
-        const score = a.score.toFixed(2);
+        const score = a.score === null ? 'keyword' : a.score.toFixed(2);
         process.stdout.write(`${kleur.cyan(a.path)} · score=${score} · by=${a.agent_id}@${a.agent_platform}\n`);
+        if (a.attribution?.reasons?.length) {
+            process.stdout.write(`  ${kleur.dim('why: ' + a.attribution.reasons.join(' · '))}\n`);
+        }
+        if (a.last_run) {
+            const lr = a.last_run;
+            process.stdout.write(`  ${kleur.dim('last run: ' + truncate(lr.task, 80) + ` [${lr.status}, ${lr.agent_platform}]`)}\n`);
+        }
         if (a.snippet)
             process.stdout.write(`  ${kleur.dim(truncate(a.snippet, 500))}\n`);
     }

package/dist/commands/init.js

@@ -5,6 +5,7 @@ import { DEFAULT_API_URL, DEFAULT_PREFERENCES, readConfig, writeConfig, } from '
 import { pollAuth } from '../lib/poll-auth.js';
 import { detectInstalledAgents, wireAgent } from '../lib/detect-agents.js';
 import { writeAllInstructions } from '../lib/auto-context.js';
+import { installClaudeSkill } from '../lib/skill.js';
 async function runPrivacyOptIn(existing, yes) {
     const start = { ...DEFAULT_PREFERENCES, ...(existing ?? {}) };
     process.stdout.write(`\n${kleur.bold('Your AI memory')}\n`);
@@ -144,6 +145,13 @@ export async function cmdInit(opts = {}) {
             process.stdout.write('  No new instructions to write.\n');
         }
     }
+    // Step 4b — install the Claude Code skill file. Skips silently when ~/.claude
+    // is missing OR when the auto-context preflight was just written above
+    // (would double-fire on the same triggers).
+    const skillResult = await installClaudeSkill();
+    if (skillResult.action === 'created' || skillResult.action === 'updated') {
+        process.stdout.write(`  ${kleur.green('+')} ${skillResult.path}\n`);
+    }
     await writeConfig({
         api_url: apiUrl,
         api_key: apiKey,

package/dist/commands/pull.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
 import { requireLogin } from '../lib/config.js';
-import { decryptContent, isEncrypted } from '../lib/crypto.js';
+import { decryptContentAsync, isEncrypted } from '../lib/crypto.js';
 export async function cmdPull(spec, opts = {}) {
     const cfg = await requireLogin();
     const client = new CliApiClient({
@@ -19,7 +19,7 @@ export async function cmdPull(spec, opts = {}) {
     const remotePath = spec.slice(slash + 1);
     const file = await client.readFileByPath(workspaceId, remotePath);
     const content = isEncrypted(file.content)
-        ? decryptContent(cfg.api_key, file.content)
+        ? await decryptContentAsync(cfg.api_key, file.content)
         : file.content;
     if (opts.out) {
         await fs.writeFile(opts.out, content, 'utf8');

package/dist/commands/push.js

@@ -3,7 +3,7 @@ import { basename } from 'node:path';
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
 import { requireLogin } from '../lib/config.js';
-import { encryptContent } from '../lib/crypto.js';
+import { encryptContentAsync } from '../lib/crypto.js';
 export async function cmdPush(localPath, opts = {}) {
     const cfg = await requireLogin();
     const client = new CliApiClient({
@@ -23,7 +23,7 @@ export async function cmdPush(localPath, opts = {}) {
         encrypt = false;
     else
         encrypt = cfg.preferences?.private_workspace ?? false;
-    const content = encrypt ? encryptContent(cfg.api_key, raw) : raw;
+    const content = encrypt ? await encryptContentAsync(cfg.api_key, raw) : raw;
     let workspaceId = opts.workspace ?? cfg.default_workspace;
     if (!workspaceId) {
         const list = await client.listWorkspaces();

package/dist/commands/timeline.js

@@ -0,0 +1,65 @@
+import kleur from 'kleur';
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+// Platform tints inspired by D4 (variant 2A "tinted pill with letter glyph").
+// Falls through to no-color on unknown / undefined platforms.
+const PLATFORM_GLYPH = {
+    'claude-code': { glyph: 'CC', tint: (s) => kleur.magenta().bold(s) },
+    codex: { glyph: 'CX', tint: (s) => kleur.cyan().bold(s) },
+    cursor: { glyph: 'CR', tint: (s) => kleur.blue().bold(s) },
+    langgraph: { glyph: 'LG', tint: (s) => kleur.yellow().bold(s) },
+    crewai: { glyph: 'CA', tint: (s) => kleur.green().bold(s) },
+    autogen: { glyph: 'AG', tint: (s) => kleur.green().bold(s) },
+    hermes: { glyph: 'HM', tint: (s) => kleur.red().bold(s) },
+    openclaw: { glyph: 'OC', tint: (s) => kleur.red().bold(s) },
+};
+function badge(platform) {
+    const key = platform ?? 'unknown';
+    const entry = PLATFORM_GLYPH[key];
+    if (!entry)
+        return kleur.dim('— ');
+    return entry.tint(entry.glyph);
+}
+function actorLabel(ev) {
+    if (ev.actor_type === 'human')
+        return ev.actor_id;
+    return ev.actor_id.length > 14 ? `${ev.actor_id.slice(0, 14)}…` : ev.actor_id;
+}
+function formatTimestamp(iso) {
+    const d = new Date(iso);
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(d.getUTCDate()).padStart(2, '0');
+    const hh = String(d.getUTCHours()).padStart(2, '0');
+    const min = String(d.getUTCMinutes()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd} ${hh}:${min}Z`;
+}
+function startOfTodayIso() {
+    const now = new Date();
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())).toISOString();
+}
+export async function cmdTimeline(opts = {}) {
+    const cfg = await requireLogin();
+    const client = new CliApiClient({
+        baseUrl: cfg.api_url,
+        apiKey: cfg.api_key,
+        agentPlatform: cfg.agent_platform ?? 'cli',
+        agentRole: cfg.agent_role,
+    });
+    const limit = opts.limit ? Number.parseInt(opts.limit, 10) : undefined;
+    const since = opts.today ? startOfTodayIso() : opts.since;
+    const { items, truncated } = await client.timeline({ since, limit });
+    if (items.length === 0) {
+        process.stdout.write('No events in window.\n');
+        return;
+    }
+    for (const ev of items) {
+        const action = kleur.cyan(ev.action.padEnd(16));
+        const target = ev.target_path ?? ev.target_id;
+        process.stdout.write(`${kleur.dim(formatTimestamp(ev.created_at))}  ${badge(ev.agent_platform)}  ` +
+            `${action} ${kleur.dim(actorLabel(ev))} ${kleur.dim('→')} ${target}\n`);
+    }
+    if (truncated) {
+        process.stdout.write(kleur.dim(`\n${items.length} shown; capped by --limit. Re-run with a tighter --since to page back.\n`));
+    }
+}

package/dist/commands/transcripts.js

@@ -0,0 +1,56 @@
+import kleur from 'kleur';
+import { requireLogin } from '../lib/config.js';
+import { claudeSource } from '../lib/transcripts/claude.js';
+import { codexSource } from '../lib/transcripts/codex.js';
+import { cursorSource } from '../lib/transcripts/cursor.js';
+import { ingestSource } from '../lib/transcripts/ingest.js';
+const SOURCES = {
+    'claude-code': claudeSource,
+    codex: codexSource,
+    cursor: cursorSource,
+};
+function selectSources(platform) {
+    if (!platform || platform === 'all') {
+        // Cursor is intentionally excluded from --all until Phase 2.5 because its
+        // enumerate() throws. Users that want it must opt in explicitly with
+        // --platform cursor and get the "not yet" error.
+        return [claudeSource, codexSource];
+    }
+    const source = SOURCES[platform];
+    if (!source) {
+        throw new Error(`Unknown platform: ${platform}. Supported: claude-code, codex, cursor, all.`);
+    }
+    return [source];
+}
+export async function cmdTranscriptsIngest(opts = {}) {
+    const cfg = await requireLogin();
+    if (!cfg.preferences?.capture_transcripts && !opts.dryRun) {
+        process.stderr.write(`${kleur.yellow('[warn]')} Remember conversations is off in your preferences.\n` +
+            `       Enable with \`adrive privacy --capture-transcripts on\`,\n` +
+            `       or run a one-off dry-run with \`adrive transcripts ingest --dry-run\`.\n`);
+        process.exit(2);
+    }
+    const sources = selectSources(opts.platform);
+    let totalIngested = 0;
+    let totalSkipped = 0;
+    for (const source of sources) {
+        try {
+            const result = await ingestSource(source, cfg, {
+                workspace: opts.workspace,
+                since: opts.since,
+                dryRun: opts.dryRun,
+                limit: opts.limit,
+                reingest: opts.reingest,
+            });
+            totalIngested += result.ingested;
+            totalSkipped += result.skipped;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`${kleur.red('[err]')} ${source.platform}: ${msg}\n`);
+        }
+    }
+    if (sources.length > 1) {
+        process.stdout.write(`\n${kleur.bold('Total')}: ${totalIngested} ingested, ${totalSkipped} skipped.\n`);
+    }
+}

package/dist/commands/watch.js

@@ -0,0 +1,110 @@
+import { promises as fs } from 'node:fs';
+import { resolve, relative, sep, posix } from 'node:path';
+import { watch as chokidarWatch } from 'chokidar';
+import kleur from 'kleur';
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+import { encryptContentAsync } from '../lib/crypto.js';
+import { redact, summarizeHits } from '../lib/redactor.js';
+import { loadRules, shouldIgnore } from '../lib/ignore.js';
+function toPosix(p) {
+    return p.split(sep).join(posix.sep);
+}
+export async function cmdWatch(rawRoot, opts = {}) {
+    const root = resolve(rawRoot ?? process.cwd());
+    const cfg = await requireLogin();
+    if (!cfg.preferences?.capture_artifacts && !opts.dryRun) {
+        process.stderr.write(`${kleur.yellow('[warn]')} Capture artifacts is off in your preferences.\n` +
+            `       Either enable it with \`adrive privacy --capture-artifacts on\`\n` +
+            `       or run a one-off dry-run with \`adrive watch --dry-run\`.\n`);
+        process.exit(2);
+    }
+    const dryRun = !!opts.dryRun;
+    const encrypt = !opts.noEncrypt && !!cfg.preferences?.private_workspace;
+    const debounceMs = opts.debounce ?? 750;
+    const rules = await loadRules(root);
+    const client = new CliApiClient({
+        baseUrl: cfg.api_url,
+        apiKey: cfg.api_key,
+        agentPlatform: cfg.agent_platform ?? 'cli',
+        agentRole: cfg.agent_role,
+    });
+    let workspaceId = opts.workspace ?? cfg.default_workspace;
+    if (!workspaceId && !dryRun) {
+        const list = await client.listWorkspaces();
+        if (list.length === 1)
+            workspaceId = list[0].id;
+        else if (list.length === 0)
+            throw new Error('No workspaces. Create one first.');
+        else
+            throw new Error(`Multiple workspaces — specify --workspace <id>.`);
+    }
+    process.stdout.write(`${kleur.bold('AgentDrive watch')}\n`);
+    process.stdout.write(`  root:        ${root}\n`);
+    process.stdout.write(`  workspace:   ${workspaceId ?? kleur.dim('(dry-run, none)')}\n`);
+    process.stdout.write(`  mode:        ${dryRun ? kleur.yellow('dry-run — nothing uploads') : kleur.green('live')}\n`);
+    process.stdout.write(`  encryption:  ${encrypt ? kleur.cyan('end-to-end on your device') : 'off'}\n`);
+    process.stdout.write(`  redactor:    on (secrets are scrubbed before anything leaves)\n\n`);
+    const queue = new Map();
+    let timer;
+    async function flush() {
+        const pending = [...queue.values()];
+        queue.clear();
+        for (const item of pending) {
+            try {
+                const raw = await fs.readFile(item.abs, 'utf8');
+                const { redacted, hits } = redact(raw);
+                const remotePath = toPosix(item.rel);
+                const tag = summarizeHits(hits);
+                if (dryRun) {
+                    process.stdout.write(`${kleur.dim('[dry]')} ${item.reason.padEnd(6)} ${remotePath} ${kleur.dim(`(${raw.length}B, redactor: ${tag})`)}\n`);
+                    continue;
+                }
+                const body = encrypt ? await encryptContentAsync(cfg.api_key, redacted) : redacted;
+                const message = `adrive watch: ${item.reason}${hits.length ? ` (redacted ${tag})` : ''}`;
+                const result = await client.writeFile(workspaceId, remotePath, body, message);
+                process.stdout.write(`${kleur.green('[ok]')}  ${item.reason.padEnd(6)} ${remotePath} v${result.version}` +
+                    (encrypt ? kleur.cyan(' (encrypted)') : '') +
+                    (hits.length ? kleur.yellow(` (redacted: ${tag})`) : '') +
+                    '\n');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`${kleur.red('[err]')} ${item.rel}: ${msg}\n`);
+            }
+        }
+    }
+    function enqueue(absPath, reason) {
+        if (shouldIgnore(root, absPath, rules))
+            return;
+        const rel = relative(root, absPath);
+        queue.set(absPath, { abs: absPath, rel, reason });
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            void flush();
+        }, debounceMs);
+    }
+    const watcher = chokidarWatch(root, {
+        ignoreInitial: false,
+        persistent: true,
+        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+        ignored: (p) => shouldIgnore(root, resolve(p), rules),
+    });
+    watcher.on('add', (p) => enqueue(resolve(p), 'add'));
+    watcher.on('change', (p) => enqueue(resolve(p), 'change'));
+    watcher.on('error', (err) => {
+        process.stderr.write(`${kleur.red('[err]')} watcher: ${String(err)}\n`);
+    });
+    const shutdown = async () => {
+        if (timer)
+            clearTimeout(timer);
+        await flush();
+        await watcher.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+    // Resolve only when the user kills the process.
+    await new Promise(() => { });
+}

package/dist/index.js

@@ -15,6 +15,9 @@ import { cmdRunLog } from './commands/run-log.js';
 import { cmdBilling } from './commands/billing.js';
 import { cmdPlan } from './commands/plan.js';
 import { cmdPrivacy } from './commands/privacy.js';
+import { cmdWatch } from './commands/watch.js';
+import { cmdTranscriptsIngest } from './commands/transcripts.js';
+import { cmdTimeline } from './commands/timeline.js';
 // Read from the bundled package.json so we never drift again.
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -101,10 +104,19 @@ program
     workspace: opts.workspace,
 })));
 program
-    .command('context <task>')
+    .command('timeline')
+    .description('Cross-agent activity stream for your org')
+    .option('--today', 'Only events since midnight UTC')
+    .option('--since <iso>', 'Only events strictly after this ISO datetime')
+    .option('--limit <n>', 'Max events to show (default 200, max 1000)')
+    .action(wrap((opts) => cmdTimeline(opts)));
+program
+    .command('context [task]')
     .description('Auto-pull relevant artifacts for a task')
     .option('--limit <n>', 'Max artifacts to return')
     .option('-w, --workspace <id>', 'Restrict to one workspace')
+    .option('--install-skill', 'Install the Claude Code SKILL.md (~/.claude/skills/agentdrive/)')
+    .option('--force', 'With --install-skill, write even if the auto-context preflight is already in CLAUDE.md')
     .action(wrap((task, opts) => cmdContext(task, opts)));
 program
     .command('run-log <task>')
@@ -127,6 +139,37 @@ program
     .command('plan')
     .description('Show current plan, usage, and quotas')
     .action(wrap(() => cmdPlan()));
+program
+    .command('watch [path]')
+    .description('Capture files your agents write under the given path (default: cwd)')
+    .option('-w, --workspace <id>', 'Workspace id (default: only workspace)')
+    .option('--dry-run', 'Print what would be uploaded; never write')
+    .option('--no-encrypt', 'Skip end-to-end encryption even when private workspace is on')
+    .option('--debounce <ms>', 'Coalesce changes within this window', (v) => Number(v))
+    .action(wrap((path, opts) => cmdWatch(path, {
+    workspace: opts.workspace,
+    dryRun: opts.dryRun,
+    noEncrypt: opts.encrypt === false,
+    debounce: opts.debounce,
+})));
+const transcripts = program.command('transcripts').description('Ingest chat transcripts from local agent hosts');
+transcripts
+    .command('ingest')
+    .description('Read recent transcripts, redact secrets, upload to AgentDrive')
+    .option('--platform <p>', 'claude-code | codex | cursor | all (default: all)', 'all')
+    .option('-w, --workspace <id>', 'Target workspace id')
+    .option('--since <date>', 'Ignore transcripts older than this ISO date')
+    .option('--limit <n>', 'Cap how many to ingest', (v) => Number(v))
+    .option('--dry-run', 'Print what would be uploaded; never write')
+    .option('--reingest', 'Re-upload sessions already in the manifest')
+    .action(wrap((opts) => cmdTranscriptsIngest({
+    platform: opts.platform,
+    workspace: opts.workspace,
+    since: opts.since,
+    limit: opts.limit,
+    dryRun: opts.dryRun,
+    reingest: opts.reingest,
+})));
 program
     .command('privacy')
     .description('Show or change your privacy + memory preferences')

package/dist/lib/api-client.js

@@ -119,4 +119,19 @@ export class CliApiClient {
     async billingPlan() {
         return this.request('GET', '/billing/plan');
     }
+    async timeline(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.since)
+            params.set('since', opts.since);
+        if (typeof opts.limit === 'number')
+            params.set('limit', String(opts.limit));
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const url = `${this.baseUrl}/v1/org/timeline${query}`;
+        const res = await fetch(url, { method: 'GET', headers: this.headers(true) });
+        const json = (await res.json());
+        if (!res.ok || !json.success) {
+            throw new Error(json.error ?? `API request failed (${res.status})`);
+        }
+        return { items: (json.data ?? []), truncated: !!json.truncated };
+    }
 }

package/dist/lib/crypto.js

@@ -1,26 +1,26 @@
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync, } from 'node:crypto';
-// AgentDrive private-workspace encryption.
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { loadDek } from './keychain.js';
+// AgentDrive private-workspace encryption (v1).
 //
-// Goal: a file uploaded with privacy on is opaque to the server. Even if our
-// storage is breached, the bytes are unreadable without the local key.
+// Sync API (`encryptContent` / `decryptContent`) keeps the legacy v0
+// derivation: scrypt(apiKey, fixedSalt). Used by tests + any caller that
+// can't await. The async API (`encryptContentAsync` / `decryptContentAsync`)
+// uses the keychain-stored DEK from lib/keychain.ts — that's the path the
+// real `adrive push` / `adrive pull` take.
 //
-// v0 derives the workspace data key from the API key with a scrypt KDF and a
-// fixed salt. That gives a single client-side key per principal — enough to
-// protect content from the server, not enough to protect content from a
-// compromised API key. v1 moves the master key into the OS keychain and uses
-// per-workspace data keys wrapped by it.
-const SALT = Buffer.from('agentdrive.privacy.v0', 'utf8');
-const KEY_LENGTH = 32; // AES-256
-const IV_LENGTH = 12; // GCM standard
-const TAG_LENGTH = 16; // GCM standard
+// Why two paths: a published v0.2.x ciphertext on disk should still decrypt
+// after the upgrade. The async path is opt-in and used for new writes.
+const LEGACY_SALT = Buffer.from('agentdrive.privacy.v0', 'utf8');
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+const TAG_LENGTH = 16;
 const SCRYPT_COST = 1 << 14;
 const SCRYPT_MAXMEM = 64 * 1024 * 1024;
 const ENCRYPTED_PREFIX = 'agentdrive-encrypted:v0:';
 export function deriveWorkspaceKey(apiKey) {
-    return scryptSync(apiKey, SALT, KEY_LENGTH, { N: SCRYPT_COST, maxmem: SCRYPT_MAXMEM });
+    return scryptSync(apiKey, LEGACY_SALT, KEY_LENGTH, { N: SCRYPT_COST, maxmem: SCRYPT_MAXMEM });
 }
-export function encryptContent(apiKey, plaintext) {
-    const key = deriveWorkspaceKey(apiKey);
+function encryptWithKey(key, plaintext) {
     const iv = randomBytes(IV_LENGTH);
     const cipher = createCipheriv('aes-256-gcm', key, iv);
     const buf = typeof plaintext === 'string' ? Buffer.from(plaintext, 'utf8') : plaintext;
@@ -33,10 +33,7 @@ export function encryptContent(apiKey, plaintext) {
     };
     return ENCRYPTED_PREFIX + Buffer.from(JSON.stringify(payload), 'utf8').toString('base64');
 }
-export function isEncrypted(content) {
-    return typeof content === 'string' && content.startsWith(ENCRYPTED_PREFIX);
-}
-export function decryptContent(apiKey, encoded) {
+function decryptWithKey(key, encoded) {
     if (!isEncrypted(encoded)) {
         throw new Error('Content is not AgentDrive-encrypted.');
     }
@@ -47,9 +44,39 @@ export function decryptContent(apiKey, encoded) {
     if (iv.length !== IV_LENGTH || tag.length !== TAG_LENGTH) {
         throw new Error('Malformed encrypted payload.');
     }
-    const key = deriveWorkspaceKey(apiKey);
     const decipher = createDecipheriv('aes-256-gcm', key, iv);
     decipher.setAuthTag(tag);
     const ciphertext = Buffer.from(payload.ciphertext, 'base64');
     return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
 }
+export function encryptContent(apiKey, plaintext) {
+    return encryptWithKey(deriveWorkspaceKey(apiKey), plaintext);
+}
+export function decryptContent(apiKey, encoded) {
+    if (!isEncrypted(encoded)) {
+        throw new Error('Content is not AgentDrive-encrypted.');
+    }
+    return decryptWithKey(deriveWorkspaceKey(apiKey), encoded);
+}
+export async function encryptContentAsync(apiKey, plaintext) {
+    const dek = await loadDek(apiKey);
+    return encryptWithKey(dek, plaintext);
+}
+export async function decryptContentAsync(apiKey, encoded) {
+    const dek = await loadDek(apiKey);
+    try {
+        return decryptWithKey(dek, encoded);
+    }
+    catch (errKeychain) {
+        // Fallback for ciphertext written by v0 builds (pre-keychain).
+        try {
+            return decryptWithKey(deriveWorkspaceKey(apiKey), encoded);
+        }
+        catch {
+            throw errKeychain;
+        }
+    }
+}
+export function isEncrypted(content) {
+    return typeof content === 'string' && content.startsWith(ENCRYPTED_PREFIX);
+}

package/dist/lib/ignore.js

@@ -0,0 +1,137 @@
+import { promises as fs } from 'node:fs';
+import { join, relative, sep, posix } from 'node:path';
+// .adriveignore parser. Subset of gitignore semantics: blank lines and lines
+// starting with '#' are skipped; '!' negates a previous pattern; '/' anchors
+// to the project root; '**' matches across directories; '*' matches within a
+// segment.
+//
+// In addition we always layer a default-deny set on top so first-time users
+// don't accidentally upload .env / .ssh / .aws / node_modules even before
+// they edit the file.
+export const DEFAULT_DENY = [
+    '.git/',
+    'node_modules/',
+    '.next/',
+    '.open-next/',
+    '.turbo/',
+    'dist/',
+    'build/',
+    'coverage/',
+    '.cache/',
+    '.DS_Store',
+    '.env',
+    '.env.*',
+    '*.pem',
+    '*.key',
+    '*.p12',
+    '*.pfx',
+    '*.crt',
+    '.ssh/',
+    '.aws/',
+    '.gcp/',
+    '.kube/',
+    '.docker/config.json',
+    '.npmrc',
+    '.pypirc',
+    '.netrc',
+    'id_rsa',
+    'id_ed25519',
+    'credentials.json',
+    'serviceAccount.json',
+    '*.sqlite',
+    '*.sqlite3',
+    '*.db',
+    '__pycache__/',
+];
+function patternToRegex(raw) {
+    let pat = raw.trim();
+    const negate = pat.startsWith('!');
+    if (negate)
+        pat = pat.slice(1);
+    // Trailing slash means directory-only; treat it as match-anywhere-inside.
+    const dirOnly = pat.endsWith('/');
+    if (dirOnly)
+        pat = pat.slice(0, -1);
+    // Anchor to root if leading '/'.
+    const anchored = pat.startsWith('/');
+    if (anchored)
+        pat = pat.slice(1);
+    let re = '';
+    let i = 0;
+    while (i < pat.length) {
+        const c = pat[i];
+        if (c === '*') {
+            // '**' matches anything including slashes; single '*' matches within
+            // a path segment only.
+            if (pat[i + 1] === '*') {
+                re += '.*';
+                i += 2;
+                if (pat[i] === '/')
+                    i++;
+            }
+            else {
+                re += '[^/]*';
+                i++;
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+            i++;
+        }
+        else if ('.+^$()[]{}|\\'.includes(c)) {
+            re += '\\' + c;
+            i++;
+        }
+        else {
+            re += c;
+            i++;
+        }
+    }
+    // dirOnly: match the dir itself or anything under it.
+    if (dirOnly)
+        re += '(?:/.*)?';
+    // anchored = at root only; unanchored = at any depth.
+    const final = anchored ? `^${re}$` : `^(?:.*/)?${re}$`;
+    return { re: new RegExp(final), negate };
+}
+export function compileRules(lines) {
+    const rules = [];
+    for (const raw of lines) {
+        const line = raw.replace(/^\s+|\s+$/g, '');
+        if (!line || line.startsWith('#'))
+            continue;
+        const { re, negate } = patternToRegex(line);
+        rules.push({ pattern: line, negate, re });
+    }
+    return rules;
+}
+export async function loadRules(root) {
+    const candidates = [join(root, '.adriveignore'), join(root, '.gitignore')];
+    const lines = [...DEFAULT_DENY];
+    for (const c of candidates) {
+        try {
+            const raw = await fs.readFile(c, 'utf8');
+            lines.push(...raw.split(/\r?\n/));
+        }
+        catch {
+            // ignore missing
+        }
+    }
+    return compileRules(lines);
+}
+function normalizeRelative(root, path) {
+    const rel = relative(root, path);
+    return rel.split(sep).join(posix.sep);
+}
+export function shouldIgnore(root, path, rules) {
+    const rel = normalizeRelative(root, path);
+    if (!rel || rel.startsWith('..'))
+        return true;
+    let ignored = false;
+    for (const r of rules) {
+        if (r.re.test(rel)) {
+            ignored = !r.negate;
+        }
+    }
+    return ignored;
+}