@adrive/cli 1.0.0 → 1.1.1

package/dist/lib/harness-wiring.js

@@ -0,0 +1,194 @@
+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;
+}
+// This repo is private; agentdrive-mcp carries a public copy of .claude-plugin/ and plugins/.
+export const CLAUDE_MARKETPLACE = 'Rakesh1002/agentdrive-mcp';
+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

@@ -1,117 +1,58 @@
-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.
+// 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: |
-  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.
+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 — shared artifact workspace for multi-agent workflows
+# AgentDrive
 
-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.
+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.
 
-## When to use this skill
+## Sessions
 
-Trigger on any of these patterns:
+- "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\`).
 
-- "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
+Both default to the current project.
 
-## Commands
+## Context and search
 
-\`\`\`
-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
-\`\`\`
+- 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
 
-\`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.
+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.
 
-## Output handling
+## 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
+\`\`\`
 
-\`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.
+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\` settings. If the user has "Private workspace" on,
-written content is encrypted client-side; server stores only ciphertext.
+Respect \`adrive privacy\`. With "Private workspace" on, content is encrypted
+on the device and the 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)';
-    }
-}