@adrive/cli 0.3.0 → 1.1.0

package/dist/lib/harness-commands.js

@@ -0,0 +1,63 @@
+const ARGS = '{{ARGS}}';
+const TEMPLATES = {
+    resume: {
+        description: 'Resume an AgentDrive session from any agent harness',
+        argumentHint: '[session-id]',
+        body: `Resume earlier agent work from AgentDrive.
+
+1. Call the \`drive_resume\` MCP tool. If a session id was given (${ARGS}), pass it as \`session_id\`; otherwise call it with no arguments to get the most recent session for this project.
+2. Summarize the handoff for the user in 3-5 bullets: the goal, what is done, what is left, and any open questions.
+3. Before relying on the handoff, check the current state on disk of the files it mentions; the work may have changed since that session ended.
+4. Continue the work from where it stopped.
+
+If the \`drive_resume\` tool is not available, run \`adrive resume\` in the shell (add the session id if one was given) and use its output as the handoff.
+`,
+    },
+    sessions: {
+        description: 'List recent AgentDrive sessions across agent harnesses',
+        argumentHint: '[platform or project]',
+        body: `List recent agent sessions captured by AgentDrive.
+
+Call the \`drive_sessions\` MCP tool. If a filter was given (${ARGS}), pass a harness name (claude-code, codex, opencode, gemini-cli, cursor) as \`platform\` and anything else as \`project\`.
+
+Show the result as a compact list: session id, harness, project, when it was last active, and a one-line summary. Then tell the user they can pick one up with the AgentDrive resume command and its session id.
+
+If the \`drive_sessions\` tool is not available, run \`adrive resume --list\` in the shell instead.
+`,
+    },
+    login: {
+        description: 'Log in to AgentDrive and connect your other agent harnesses',
+        body: `Log the user in to AgentDrive and connect their other agent tools.
+
+1. Run \`npx -y @adrive/cli auth login\` in the shell. It opens a browser for sign-in and waits until it completes; tell the user to finish signing in there.
+2. When it succeeds, run \`npx -y @adrive/cli init --yes\` to wire AgentDrive into Codex, OpenCode, Gemini CLI, and Cursor where they are installed.
+3. Relay init's summary to the user, including any one-time step it asks for (such as approving the hooks in Codex via /hooks).
+`,
+    },
+};
+// Login is plugin-only: init itself is what wires the other harnesses, so it
+// has already logged in by the time their commands exist.
+export const HARNESS_COMMANDS = ['resume', 'sessions'];
+// Codex prompts, OpenCode, and Cursor commands share a flat namespace with
+// built-ins such as /resume and /sessions, so they get a prefix.
+export function commandFileName(harness, name) {
+    if (harness === 'gemini-cli')
+        return `${name}.toml`;
+    if (harness === 'claude-code')
+        return `${name}.md`;
+    return `agentdrive-${name}.md`;
+}
+export function renderCommand(harness, name) {
+    const t = TEMPLATES[name];
+    if (harness === 'gemini-cli') {
+        return `description = ${JSON.stringify(t.description)}\nprompt = """\n${t.body.replace(ARGS, '{{args}}')}"""\n`;
+    }
+    if (harness === 'cursor') {
+        return t.body.replace(ARGS, 'the text after the command, if any');
+    }
+    const body = t.body.replace(ARGS, '$ARGUMENTS');
+    const front = [`description: ${t.description}`];
+    if (harness !== 'opencode' && t.argumentHint)
+        front.push(`argument-hint: "${t.argumentHint}"`);
+    return `---\n${front.join('\n')}\n---\n\n${body}`;
+}

package/dist/lib/harness-wiring.js

@@ -0,0 +1,193 @@
+import { spawnSync } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { mergeCodexToml, mergeMcpJson, mergeOpencodeJson } from './detect-agents.js';
+import { HARNESS_COMMANDS, commandFileName, renderCommand } from './harness-commands.js';
+import { SKILL_MARKDOWN } from './skill.js';
+import { readJsonObject, readTextIfExists, writeFileIfChanged, writeJsonIfChanged, } from './write-file.js';
+export const HOOK_HARNESSES = ['codex', 'opencode', 'gemini-cli', 'cursor'];
+export const HARNESS_LABELS = {
+    codex: 'Codex',
+    opencode: 'OpenCode',
+    'gemini-cli': 'Gemini CLI',
+    cursor: 'Cursor',
+};
+export const CODEX_TRUST_NOTE = 'Codex: open Codex and approve the AgentDrive hooks via /hooks.';
+// Same form as plugins/agentdrive/hooks/hooks.json: GUI-launched harnesses can
+// miss the global npm bin on PATH, so fall back to npx rather than fail.
+export function hookCommand(harness) {
+    return `command -v adrive >/dev/null 2>&1 && adrive hook ${harness} || npx -y @adrive/cli hook ${harness}`;
+}
+function asObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? { ...v } : {};
+}
+function isOurCommand(command) {
+    return typeof command === 'string' && command.includes('adrive hook');
+}
+// Replaces our entry where it already sits (dropping duplicates) or appends
+// it, so foreign hooks keep their order and a re-run is byte-identical.
+function upsert(list, desired, isOurs) {
+    const entries = Array.isArray(list) ? list : [];
+    const first = entries.findIndex((e) => isOurs(asObject(e)));
+    if (first === -1)
+        return [...entries, desired];
+    return entries.flatMap((e, i) => (i === first ? [desired] : isOurs(asObject(e)) ? [] : [e]));
+}
+function groupIsOurs(group) {
+    return Array.isArray(group.hooks) && group.hooks.some((h) => isOurCommand(asObject(h).command));
+}
+// Codex and Gemini CLI use Claude Code's {event: [{matcher?, hooks: [handler]}]} shape.
+export function mergeGroupedHooks(existing, groups) {
+    const hooks = asObject(existing.hooks);
+    for (const [event, group] of Object.entries(groups)) {
+        hooks[event] = upsert(hooks[event], group, groupIsOurs);
+    }
+    return { ...existing, hooks };
+}
+export function codexHookGroups() {
+    const group = { hooks: [{ type: 'command', command: hookCommand('codex'), timeout: 10 }] };
+    return { SessionStart: group, Stop: group, SessionEnd: group, PreCompact: group };
+}
+export function geminiHookGroups() {
+    // Gemini CLI timeouts are milliseconds.
+    const group = {
+        matcher: '*',
+        hooks: [{ type: 'command', command: hookCommand('gemini-cli'), timeout: 10000, name: 'agentdrive' }],
+    };
+    return { SessionStart: group, AfterAgent: group, SessionEnd: group, PreCompress: group };
+}
+export function mergeCursorHooks(existing) {
+    const hooks = asObject(existing.hooks);
+    const entry = { command: hookCommand('cursor'), timeout: 10 };
+    for (const event of ['sessionStart', 'stop', 'sessionEnd', 'preCompact']) {
+        hooks[event] = upsert(hooks[event], entry, (e) => isOurCommand(e.command));
+    }
+    return { version: 1, ...existing, hooks };
+}
+// Loaded by OpenCode's Bun runtime from ~/.config/opencode/plugins/. It hands
+// the session to `adrive hook opencode` and never waits on it or surfaces errors,
+// so a missing or slow adrive cannot stall OpenCode.
+export const OPENCODE_PLUGIN = `// Generated by \`adrive init\`. Re-run init to update; edits are overwritten.
+import { spawn } from 'node:child_process';
+
+function send(payload: Record<string, unknown>): void {
+  try {
+    const child = spawn('adrive', ['hook', 'opencode'], { stdio: ['pipe', 'ignore', 'ignore'], detached: true });
+    child.on('error', () => {});
+    child.stdin?.on('error', () => {});
+    child.stdin?.end(JSON.stringify(payload));
+    child.unref();
+  } catch {}
+}
+
+interface OpencodeEvent {
+  type: string;
+  properties?: { info?: { id?: string; parentID?: string; directory?: string }; sessionID?: string };
+}
+
+export const AgentDrive = async ({ directory }: { directory: string }) => ({
+  event: async ({ event }: { event: OpencodeEvent }) => {
+    if (event.type === 'session.created') {
+      const info = event.properties?.info;
+      if (!info?.id || info.parentID) return;
+      send({ hook_event_name: 'session.created', session_id: info.id, cwd: info.directory ?? directory });
+    } else if (event.type === 'session.idle' && event.properties?.sessionID) {
+      send({ hook_event_name: 'session.idle', session_id: event.properties.sessionID, cwd: directory });
+    }
+  },
+});
+
+export default { id: 'agentdrive', server: AgentDrive };
+`;
+export function harnessRoot(harness, home) {
+    switch (harness) {
+        case 'codex':
+            return join(home, '.codex');
+        case 'opencode':
+            return join(home, '.config', 'opencode');
+        case 'gemini-cli':
+            return join(home, '.gemini');
+        case 'cursor':
+            return join(home, '.cursor');
+    }
+}
+const COMMAND_DIRS = {
+    codex: 'prompts',
+    opencode: 'commands',
+    'gemini-cli': join('commands', 'agentdrive'),
+    cursor: 'commands',
+};
+export async function harnessInstalled(harness, home) {
+    try {
+        return (await fs.stat(harnessRoot(harness, home))).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function wireHarness(harness, home) {
+    const root = harnessRoot(harness, home);
+    const result = { changed: [], warnings: [] };
+    const track = async (path, write) => {
+        if ((await write) !== 'unchanged')
+            result.changed.push(path);
+    };
+    const mergeJson = async (path, merge) => track(path, writeJsonIfChanged(path, merge((await readJsonObject(path)) ?? {})));
+    switch (harness) {
+        case 'codex': {
+            await mergeJson(join(root, 'hooks.json'), (e) => mergeGroupedHooks(e, codexHookGroups()));
+            const toml = join(root, 'config.toml');
+            await track(toml, writeFileIfChanged(toml, mergeCodexToml((await readTextIfExists(toml)) ?? ''), { backup: true }));
+            break;
+        }
+        case 'opencode': {
+            const json = join(root, 'opencode.json');
+            if ((await readTextIfExists(json)) === null && (await readTextIfExists(join(root, 'opencode.jsonc'))) !== null) {
+                result.warnings.push('opencode.jsonc found; add the agentdrive MCP entry to it by hand (comments would be lost if merged)');
+            }
+            else {
+                await mergeJson(json, mergeOpencodeJson);
+            }
+            const plugin = join(root, 'plugins', 'agentdrive.ts');
+            await track(plugin, writeFileIfChanged(plugin, OPENCODE_PLUGIN));
+            break;
+        }
+        case 'gemini-cli':
+            await mergeJson(join(root, 'settings.json'), (e) => mergeGroupedHooks(mergeMcpJson(e, 'gemini-cli'), geminiHookGroups()));
+            break;
+        case 'cursor':
+            await mergeJson(join(root, 'hooks.json'), mergeCursorHooks);
+            await mergeJson(join(root, 'mcp.json'), (e) => mergeMcpJson(e, 'cursor'));
+            break;
+    }
+    for (const name of HARNESS_COMMANDS) {
+        const path = join(root, COMMAND_DIRS[harness], commandFileName(harness, name));
+        await track(path, writeFileIfChanged(path, renderCommand(harness, name)));
+    }
+    if (harness !== 'gemini-cli') {
+        const skill = join(root, 'skills', 'agentdrive', 'SKILL.md');
+        await track(skill, writeFileIfChanged(skill, SKILL_MARKDOWN));
+    }
+    return result;
+}
+export const CLAUDE_MARKETPLACE = 'Rakesh1002/agentdrive';
+export const CLAUDE_MANUAL_STEPS = [
+    `/plugin marketplace add ${CLAUDE_MARKETPLACE}`,
+    '/plugin install agentdrive@agentdrive',
+];
+export function installClaudePlugin() {
+    const steps = [
+        ['plugin', 'marketplace', 'add', CLAUDE_MARKETPLACE, '--scope', 'user'],
+        ['plugin', 'install', 'agentdrive@agentdrive', '-s', 'user', '-y'],
+    ];
+    for (const args of steps) {
+        const run = spawnSync('claude', args, { stdio: 'inherit' });
+        if (run.error?.code === 'ENOENT')
+            return { status: 'no-claude' };
+        if (run.error)
+            return { status: 'failed', detail: run.error.message };
+        if (run.status !== 0)
+            return { status: 'failed', detail: `\`claude ${args.join(' ')}\` exited ${run.status}` };
+    }
+    return { status: 'installed' };
+}

package/dist/lib/ignore.js

@@ -21,6 +21,15 @@ export const DEFAULT_DENY = [
     '.DS_Store',
     '.env',
     '.env.*',
+    '.envrc',
+    '.dev.vars',
+    '*.tfvars',
+    '*.tfstate',
+    '*.tfstate.*',
+    'secrets/',
+    '*.keystore',
+    'credentials',
+    'service-account*.json',
     '*.pem',
     '*.key',
     '*.p12',
@@ -36,6 +45,18 @@ export const DEFAULT_DENY = [
     '.netrc',
     'id_rsa',
     'id_ed25519',
+    'id_ecdsa',
+    'id_dsa',
+    '.gnupg/',
+    '.password-store/',
+    '.git-credentials',
+    '.config/gh/',
+    '.config/agentdrive/',
+    '.claude.json',
+    '.credentials.json',
+    'auth.json',
+    'oauth_creds.json',
+    '*_history',
     'credentials.json',
     'serviceAccount.json',
     '*.sqlite',
@@ -105,12 +126,11 @@ export function compileRules(lines) {
     }
     return rules;
 }
-export async function loadRules(root) {
-    const candidates = [join(root, '.adriveignore'), join(root, '.gitignore')];
+export async function loadRules(root, files = ['.adriveignore', '.gitignore']) {
     const lines = [...DEFAULT_DENY];
-    for (const c of candidates) {
+    for (const f of files) {
         try {
-            const raw = await fs.readFile(c, 'utf8');
+            const raw = await fs.readFile(join(root, f), 'utf8');
             lines.push(...raw.split(/\r?\n/));
         }
         catch {

package/dist/lib/session-cwd.js

@@ -0,0 +1,33 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+// Hooks see each session's cwd, but some transcripts (Cursor, Gemini) never
+// record it, so `adrive hook` remembers `<harness>:<session id> -> cwd` here
+// for sync to fall back on.
+const MAX_ENTRIES = 500;
+export function sessionCwdPath(configDir) {
+    return join(configDir, 'session-cwd.json');
+}
+export async function readSessionCwds(configDir) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(sessionCwdPath(configDir), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function recordSessionCwd(configDir, key, cwd) {
+    const map = await readSessionCwds(configDir);
+    if (map[key] === cwd)
+        return;
+    delete map[key];
+    map[key] = cwd;
+    const keys = Object.keys(map);
+    for (const old of keys.slice(0, Math.max(0, keys.length - MAX_ENTRIES)))
+        delete map[old];
+    await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
+    // Concurrent hooks may race; rename keeps the file whole even if one update is lost.
+    const tmp = `${sessionCwdPath(configDir)}.${process.pid}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(map), { encoding: 'utf8', mode: 0o600 });
+    await fs.rename(tmp, sessionCwdPath(configDir));
+}

package/dist/lib/skill.js

@@ -0,0 +1,58 @@
+// Must stay byte-identical to plugins/agentdrive/skills/agentdrive/SKILL.md
+// (the Claude Code plugin copy); test/skill.test.ts enforces it. adrive init
+// writes this into the Codex, OpenCode, and Cursor skill directories.
+export const SKILL_MARKDOWN = `---
+name: agentdrive
+description: Cross-agent session memory and artifact workspace. Use when the user wants to continue work another agent session started (Claude Code, Codex, OpenCode, Gemini CLI, Cursor), asks what an earlier session did, needs prior context for a task, or wants to save an artifact for their other agents.
+---
+
+# AgentDrive
+
+AgentDrive captures the user's agent sessions in the background and makes any
+of them resumable from any harness. Prefer the \`drive_*\` MCP tools; fall back
+to the \`adrive\` CLI when they are not available.
+
+## Sessions
+
+- "Continue where I left off", "pick up the Codex session", "what was I
+  doing?": call \`drive_resume\` (optionally with \`session_id\` or
+  \`platform\`). Summarize the handoff in a few bullets, check the files it
+  mentions on disk, then continue the work.
+- "What sessions do I have?", "what did Cursor do today?": call
+  \`drive_sessions\` (filters: \`project\`, \`platform\`, \`limit\`).
+
+Both default to the current project.
+
+## Context and search
+
+- Starting a non-trivial task: call \`drive_context\` with a one-line summary
+  of the task to get relevant artifacts and runs from earlier work.
+- Looking for something specific: call \`drive_search\`.
+
+When citing a result, say why it surfaced (\`attribution.reasons\`) and mention
+the \`last_run\` task when present.
+
+## Saving work
+
+After producing a file worth sharing with the user's other agents, call
+\`drive_write\`. Transcripts and files git doesn't track are already captured
+automatically when the user has capture on, so don't re-upload them.
+
+## CLI fallback
+
+\`\`\`
+adrive resume [session-id]   # print a session handoff
+adrive resume --list         # list recent sessions
+adrive context "<task>"      # relevant artifacts for a task
+adrive search "<query>"      # semantic search
+adrive push <file>           # save an artifact
+\`\`\`
+
+If \`adrive\` says the user is not logged in, ask them to run \`adrive init\`
+(or \`/agentdrive:login\` in Claude Code). Never guess credentials.
+
+## Privacy
+
+Respect \`adrive privacy\`. With "Private workspace" on, content is encrypted
+on the device and the server stores only ciphertext.
+`;