@adrive/cli 1.1.1 → 1.1.2

package/README.md

@@ -80,4 +80,4 @@ Merges preserve everything else in each file, the first change to an existing fi
 
 ## License
 
-Apache-2.0. See the repo's [LICENSING.md](https://github.com/Rakesh1002/agentdrive/blob/main/LICENSING.md) for the full package-by-package breakdown.
+Apache-2.0.

package/dist/commands/hook.js

@@ -7,16 +7,19 @@ import { HARNESSES } from '../lib/sync.js';
 import { recordSessionCwd } from '../lib/session-cwd.js';
 import { asObj, asStr, truncate } from '../lib/transcripts/util.js';
 // Entry point for every harness lifecycle hook. Hooks run inline with the
-// agent (Codex gives SessionEnd 1s), so this answers fast, hands the real
+// agent (Codex clamps hook timeouts to 3s), so this answers fast, hands the real
 // work to a detached `adrive sync`, never throws, and always exits 0. stdout
 // is reserved for the harness's JSON protocol.
 const STDIN_TIMEOUT_MS = 1000;
 const CONTEXT_TIMEOUT_MS = 1500;
 const MAX_CONTEXT_SESSIONS = 3;
+const CONTEXT_FETCH = 20;
 const NOT_CONNECTED = 'AgentDrive is installed but not connected: run `adrive auth login`.';
 const START_EVENTS = new Set(['SessionStart', 'sessionStart', 'session.created']);
-const FORCE_EVENTS = new Set(['SessionEnd', 'sessionEnd', 'PreCompact', 'preCompact', 'PreCompress']);
-const TURN_EVENTS = new Set(['Stop', 'stop', 'AfterAgent', 'session.idle']);
+// OpenCode has no end event and its idle often lands within the debounce of
+// session.created, so a debounced idle would leave a one-shot session empty.
+const FORCE_EVENTS = new Set(['SessionEnd', 'sessionEnd', 'PreCompact', 'preCompact', 'PreCompress', 'session.idle']);
+const TURN_EVENTS = new Set(['Stop', 'stop', 'AfterAgent']);
 export function classifyEvent(name) {
     if (START_EVENTS.has(name))
         return 'start';
@@ -42,11 +45,14 @@ function age(ms) {
 }
 async function recentSessions(cfg, harness, cwd, sessionId, now) {
     const client = new CliApiClient({ baseUrl: cfg.api_url, apiKey: cfg.api_key, agentPlatform: harness, agentRole: cfg.agent_role });
-    const runs = await client.listRuns({ project: scopeProjectKey(projectKeyFor(cwd), !!cfg.preferences?.private_workspace), limit: 5, timeoutMs: CONTEXT_TIMEOUT_MS }).catch(() => []);
+    const runs = await client.listRuns({ project: scopeProjectKey(projectKeyFor(cwd), !!cfg.preferences?.private_workspace), limit: CONTEXT_FETCH, timeoutMs: CONTEXT_TIMEOUT_MS }).catch(() => []);
     const current = sessionId ? sessionRunId(harness, sessionId) : undefined;
-    const lines = runs
-        .filter((r) => r.run_id !== current)
-        .slice(0, MAX_CONTEXT_SESSIONS)
+    const others = runs.filter((r) => r.run_id !== current);
+    // The newest session of every other harness first, so a burst of short runs in one harness cannot hide the rest.
+    const firsts = others.filter((r, i) => r.agent_platform !== harness && others.findIndex((o) => o.agent_platform === r.agent_platform) === i);
+    const picked = [...new Set([...firsts, ...others])].slice(0, MAX_CONTEXT_SESSIONS);
+    const lines = others
+        .filter((r) => picked.includes(r))
         .map((r) => {
         const title = truncate(asStr(r.metadata?.title) || r.task, 120);
         return `- ${r.agent_platform} · ${age(now - sessionActivityAt(r))} · "${title}" (id ${r.run_id})`;
@@ -140,13 +146,14 @@ function readStdin(timeoutMs) {
     });
 }
 export async function cmdHook(harness) {
+    let out = '';
     try {
-        const out = await runHook(harness, await readStdin(STDIN_TIMEOUT_MS));
-        if (out)
-            process.stdout.write(`${out}\n`);
+        out = await runHook(harness, await readStdin(STDIN_TIMEOUT_MS));
     }
     catch {
-        // runHook already swallows; this guards stdin/stdout edge cases.
+        // runHook already swallows; this guards stdin edge cases.
     }
-    process.exitCode = 0;
+    // Exit explicitly: an aborted context fetch keeps its socket connecting for
+    // ~10s, and harnesses wait for the hook process to exit.
+    process.stdout.write(out ? `${out}\n` : '', () => process.exit(0));
 }

package/dist/commands/init.js

@@ -9,7 +9,7 @@ import { ensureCaptureConsent } from '../lib/consent.js';
 import { pollAuth } from '../lib/poll-auth.js';
 import { detectInstalledAgents, wireAgent } from '../lib/detect-agents.js';
 import { writeAllInstructions } from '../lib/auto-context.js';
-import { CLAUDE_MANUAL_STEPS, CODEX_TRUST_NOTE, HARNESS_LABELS, HOOK_HARNESSES, harnessInstalled, installClaudePlugin, wireHarness, } from '../lib/harness-wiring.js';
+import { CLAUDE_MANUAL_STEPS, CODEX_TRUST_NOTE, HARNESS_LABELS, HOOK_HARNESSES, harnessInstalled, installClaudePlugin, removeLegacyClaudeSkill, wireHarness, } from '../lib/harness-wiring.js';
 async function runPrivacyOptIn(existing, yes) {
     const start = { ...DEFAULT_PREFERENCES, ...(existing ?? {}) };
     process.stdout.write(`\n${kleur.bold('Your AI memory')}\n`);
@@ -125,7 +125,19 @@ export async function cmdInit(opts = {}) {
     await writeConfig(config);
     process.stdout.write(`\n${kleur.bold('Step 2.')} Connect agent harnesses.\n`);
     const summary = [];
-    summary.push(['Claude Code', await wireClaudeCode(yes, home)]);
+    const claude = await wireClaudeCode(yes, home);
+    summary.push(['Claude Code', claude]);
+    // Until the plugin is in, the old skill is the only AgentDrive integration Claude Code has.
+    if (claude.startsWith('wired')) {
+        try {
+            const legacy = await removeLegacyClaudeSkill(home);
+            if (legacy)
+                process.stdout.write(`  ${kleur.green('-')} ${legacy} (old CLI copy; the Claude Code plugin ships the skill now)\n`);
+        }
+        catch (err) {
+            process.stdout.write(`  ${kleur.yellow('!')} could not remove the old AgentDrive skill: ${errorMessage(err)}\n`);
+        }
+    }
     let codexWired = false;
     for (const h of HOOK_HARNESSES) {
         const label = HARNESS_LABELS[h];
@@ -143,7 +155,7 @@ export async function cmdInit(opts = {}) {
                 process.stdout.write(`  ${kleur.green('+')} ${p}\n`);
             for (const w of wiring.warnings)
                 process.stdout.write(`  ${kleur.yellow('!')} ${label}: ${w}\n`);
-            summary.push([label, wiring.changed.length ? 'wired' : 'wired (already up to date)']);
+            summary.push([label, wiring.warnings.length ? 'manual step needed (see above)' : wiring.changed.length ? 'wired' : 'wired (already up to date)']);
             if (h === 'codex')
                 codexWired = true;
         }

package/dist/commands/resume.js

@@ -36,6 +36,9 @@ export async function cmdResume(id, opts = {}) {
         throw new Error(`Session ${run.run_id} has no uploaded transcript.`);
     }
     const file = await client.readFileByPath(run.workspace_id, transcriptPath);
-    const markdown = isEncrypted(file.content) ? await decryptContentAsync(cfg.api_key, file.content) : file.content;
-    process.stdout.write(`${buildHandoff(markdown, opts.maxChars)}\n`);
+    const encrypted = isEncrypted(file.content);
+    const markdown = encrypted ? await decryptContentAsync(cfg.api_key, file.content) : file.content;
+    // drive_read cannot decrypt, so a private session's uploads are not offered.
+    const uploads = encrypted ? undefined : { workspaceId: run.workspace_id, fileIds: run.artifacts_produced };
+    process.stdout.write(`${buildHandoff(markdown, opts.maxChars, uploads)}\n`);
 }

package/dist/lib/auto-context.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { codexHome, opencodeConfigDir } from './config.js';
 import { readTextIfExists, writeFileIfChanged } from './write-file.js';
 // Small instructions block written into each agent host's persistent
 // preamble (AGENTS.md, GEMINI.md, cursor rules). Tells the agent when to
@@ -29,10 +30,11 @@ Privacy: the user controls capture and encryption with \`adrive privacy\`.
 With "Private workspace" on, content is end-to-end encrypted on their
 device; the AgentDrive server stores only ciphertext.
 ${END}`;
-export function getInstructionsTargets(home = homedir()) {
-    const opencode = join(home, '.config', 'opencode');
+export function getInstructionsTargets(home = homedir(), env = process.env) {
+    const codex = codexHome(env, home);
+    const opencode = opencodeConfigDir(env, home);
     return [
-        { root: join(home, '.codex'), path: join(home, '.codex', 'AGENTS.md'), format: 'markdown' },
+        { root: codex, path: join(codex, 'AGENTS.md'), format: 'markdown' },
         { root: opencode, path: join(opencode, 'AGENTS.md'), format: 'markdown' },
         { root: join(home, '.gemini'), path: join(home, '.gemini', 'GEMINI.md'), format: 'markdown' },
         { root: join(home, '.cursor'), path: join(home, '.cursor', 'rules', 'agentdrive.mdc'), format: 'cursor-mdc' },
@@ -67,16 +69,16 @@ export async function writeInstructions(target) {
     }
     return { path: target.path, action: await writeFileIfChanged(target.path, next, { backup: true }) };
 }
-export async function writeAllInstructions(home = homedir()) {
+export async function writeAllInstructions(home = homedir(), env = process.env) {
     const out = [];
-    for (const t of getInstructionsTargets(home)) {
+    for (const t of getInstructionsTargets(home, env)) {
         if (await dirExists(t.root))
             out.push(await writeInstructions(t));
     }
     return out;
 }
-export async function removeAllInstructions(home = homedir()) {
-    const targets = getInstructionsTargets(home);
+export async function removeAllInstructions(home = homedir(), env = process.env) {
+    const targets = getInstructionsTargets(home, env);
     for (const t of targets) {
         try {
             const current = await fs.readFile(t.path, 'utf8');

package/dist/lib/config.js

@@ -13,6 +13,15 @@ export function configDir(env = process.env, home = homedir()) {
     const base = xdg && xdg.length > 0 ? xdg : join(home, '.config');
     return join(base, 'agentdrive');
 }
+export function codexHome(env = process.env, home = homedir()) {
+    return env.CODEX_HOME || join(home, '.codex');
+}
+export function opencodeConfigDir(env = process.env, home = homedir()) {
+    return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'opencode');
+}
+export function opencodeDataDir(env = process.env, home = homedir()) {
+    return join(env.XDG_DATA_HOME || join(home, '.local', 'share'), 'opencode');
+}
 export function configPath(env = process.env, home = homedir()) {
     return join(configDir(env, home), 'config.json');
 }

package/dist/lib/detect-agents.js

@@ -96,7 +96,10 @@ export function mergeOpencodeJson(existing) {
     return base;
 }
 const CODEX_BLOCK = '[mcp_servers.agentdrive]\ncommand = "npx"\nargs = ["-y", "@adrive/mcp-server"]\n\n' +
-    '[mcp_servers.agentdrive.env]\nAGENTDRIVE_AGENT_PLATFORM = "codex"\n';
+    '[mcp_servers.agentdrive.env]\nAGENTDRIVE_AGENT_PLATFORM = "codex"\n' +
+    // codex exec runs with approval policy "never", which refuses MCP calls unless the tool is pre-approved; only the read-only ones are.
+    '\n[mcp_servers.agentdrive.tools.drive_sessions]\napproval_mode = "approve"\n' +
+    '\n[mcp_servers.agentdrive.tools.drive_resume]\napproval_mode = "approve"\n';
 // Line-based so every table we don't own keeps its exact text. Drops our
 // [mcp_servers.agentdrive*] tables plus the [[mcp_servers]] name="agentdrive"
 // array entry older CLIs wrote, which would make the file invalid TOML next

package/dist/lib/harness-wiring.js

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
+import { codexHome, opencodeConfigDir } from './config.js';
 import { mergeCodexToml, mergeMcpJson, mergeOpencodeJson } from './detect-agents.js';
 import { HARNESS_COMMANDS, commandFileName, renderCommand } from './harness-commands.js';
 import { SKILL_MARKDOWN } from './skill.js';
@@ -45,7 +46,8 @@ export function mergeGroupedHooks(existing, groups) {
     return { ...existing, hooks };
 }
 export function codexHookGroups() {
-    const group = { hooks: [{ type: 'command', command: hookCommand('codex'), timeout: 10 }] };
+    // Codex clamps hook timeouts above 3s and reports it as an error item on every run.
+    const group = { hooks: [{ type: 'command', command: hookCommand('codex'), timeout: 3 }] };
     return { SessionStart: group, Stop: group, SessionEnd: group, PreCompact: group };
 }
 export function geminiHookGroups() {
@@ -99,12 +101,12 @@ export const AgentDrive = async ({ directory }: { directory: string }) => ({
 
 export default { id: 'agentdrive', server: AgentDrive };
 `;
-export function harnessRoot(harness, home) {
+export function harnessRoot(harness, home, env = process.env) {
     switch (harness) {
         case 'codex':
-            return join(home, '.codex');
+            return codexHome(env, home);
         case 'opencode':
-            return join(home, '.config', 'opencode');
+            return opencodeConfigDir(env, home);
         case 'gemini-cli':
             return join(home, '.gemini');
         case 'cursor':
@@ -117,16 +119,16 @@ const COMMAND_DIRS = {
     'gemini-cli': join('commands', 'agentdrive'),
     cursor: 'commands',
 };
-export async function harnessInstalled(harness, home) {
+export async function harnessInstalled(harness, home, env = process.env) {
     try {
-        return (await fs.stat(harnessRoot(harness, home))).isDirectory();
+        return (await fs.stat(harnessRoot(harness, home, env))).isDirectory();
     }
     catch {
         return false;
     }
 }
-export async function wireHarness(harness, home) {
-    const root = harnessRoot(harness, home);
+export async function wireHarness(harness, home, env = process.env) {
+    const root = harnessRoot(harness, home, env);
     const result = { changed: [], warnings: [] };
     const track = async (path, write) => {
         if ((await write) !== 'unchanged')
@@ -142,8 +144,13 @@ export async function wireHarness(harness, home) {
         }
         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)');
+            const jsonc = join(root, 'opencode.jsonc');
+            if ((await readTextIfExists(json)) === null && (await readTextIfExists(jsonc)) !== null) {
+                // A fresh OpenCode writes plain JSON into opencode.jsonc; only real JSONC would lose comments on a merge.
+                if (await readJsonObject(jsonc).then(() => true, () => false))
+                    await mergeJson(jsonc, mergeOpencodeJson);
+                else
+                    result.warnings.push('opencode.jsonc has comments; add the agentdrive MCP entry to it by hand (they would be lost if merged)');
             }
             else {
                 await mergeJson(json, mergeOpencodeJson);
@@ -170,6 +177,23 @@ export async function wireHarness(harness, home) {
     }
     return result;
 }
+// CLI 1.0.0 wrote this skill; the Claude Code plugin now ships it, and OpenCode
+// also loads ~/.claude/skills, so the copy shows up as a duplicate skill there.
+export async function removeLegacyClaudeSkill(home) {
+    const dir = join(home, '.claude', 'skills', 'agentdrive');
+    const skill = join(dir, 'SKILL.md');
+    // A linked folder is shared with other agents or a dev checkout; deleting through it would reach outside ~/.claude.
+    if (!(await fs.lstat(dir).then((st) => st.isDirectory(), () => false)))
+        return null;
+    const text = await readTextIfExists(skill);
+    const frontmatter = text && /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1];
+    if (!frontmatter || !/^name:[ \t]*agentdrive[ \t]*\r?$/m.test(frontmatter))
+        return null;
+    await fs.rm(skill);
+    // Anything else the user put there stays.
+    await fs.rmdir(dir).catch(() => undefined);
+    return skill;
+}
 // 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 = [

package/dist/lib/sync.js

@@ -147,7 +147,7 @@ function makeLogger(quiet, dir) {
 function defaultClient(cfg, harness) {
     return new CliApiClient({ baseUrl: cfg.api_url, apiKey: cfg.api_key, agentPlatform: harness, agentRole: cfg.agent_role });
 }
-// shortcut: no trailing-edge debounce; the last turn of a session without an end hook syncs on the next sweep from any harness.
+// shortcut: no trailing-edge debounce; a debounced last turn with no end event after it (a killed agent) syncs on the next sweep from any harness. Add a delayed re-sync if that lag matters.
 export async function runSync(opts = {}) {
     const result = { synced: [], unchanged: 0, debounced: 0, failed: 0, perHarness: {} };
     const dir = opts.configDir ?? defaultConfigDir();
@@ -200,7 +200,8 @@ export async function runSync(opts = {}) {
             const entry = await locate(sources[opts.harness], opts, home, dir);
             if (entry)
                 candidates.push({ harness: opts.harness, entry, explicit: true });
-            else
+            // A starting session usually has no transcript yet.
+            else if (!opts.start)
                 await log(`${opts.harness} session ${opts.session ?? opts.transcript} not found`);
         }
         const sweep = !named || !!opts.all || !!opts.start || !!opts.force || !manifest.last_sweep_at || now - manifest.last_sweep_at > DEBOUNCE_MS;
@@ -214,7 +215,7 @@ export async function runSync(opts = {}) {
             for (const harness of opts.harness && !named ? [opts.harness] : HARNESSES) {
                 let entries;
                 try {
-                    entries = await sources[harness].enumerate({ home, since, configDir: dir, cwd: opts.cwd ?? process.cwd() });
+                    entries = await sources[harness].enumerate({ home, since, configDir: dir, cwd: opts.cwd ?? process.cwd(), env: opts.env });
                 }
                 catch (err) {
                     await log(`${harness} enumerate failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -229,7 +230,7 @@ export async function runSync(opts = {}) {
                     found.push({ harness, entry, explicit: false });
                 }
             }
-            // Sessions with no end event (OpenCode always, or a killed agent) never
+            // Sessions whose end event never came (a killed agent) never
             // change again, so a stale in_progress entry is revisited to finalize it.
             for (const [runId, rec] of Object.entries(manifest.sessions)) {
                 if (rec.status !== 'in_progress' || !rec.harness || !rec.path || now - rec.synced_at < DEBOUNCE_MS)
@@ -301,11 +302,12 @@ async function locate(source, opts, home, dir) {
         const sessionId = opts.session ?? basename(opts.transcript).replace(/\.jsonl?(\.zst)?$/, '');
         return { sessionId, path: opts.transcript, mtime, cwd: opts.cwd };
     }
-    const entries = await source.enumerate({ home, configDir: dir, cwd: opts.cwd });
+    const entries = await source.enumerate({ home, configDir: dir, cwd: opts.cwd, env: opts.env });
     const hit = entries.find((e) => e.sessionId === opts.session);
     return hit ? { ...hit, cwd: hit.cwd ?? opts.cwd } : null;
 }
-const homeRules = compileRules(DEFAULT_DENY);
+// A hard gate: project .adriveignore files are untrusted and could negate DEFAULT_DENY.
+const denyRules = compileRules(DEFAULT_DENY);
 async function syncSession(ctx, c, result) {
     const { opts, manifest, now } = ctx;
     if (!opts.force && now - (manifest.sessions[sessionRunId(c.harness, c.entry.sessionId)]?.synced_at ?? 0) < DEBOUNCE_MS) {
@@ -364,9 +366,13 @@ async function syncSession(ctx, c, result) {
         const realCwd = cwd ? await realpathSafe(cwd) : null;
         for (const abs of absPaths) {
             const real = await realpathSafe(abs);
-            if (!real || shouldIgnore(ctx.realHome, real, homeRules))
+            if (!real)
                 continue;
             const inCwd = !!realCwd && isInside(realCwd, real);
+            // Outside home only the session's own project is in scope, and a filesystem-root cwd is no project.
+            const root = isInside(ctx.realHome, real) ? ctx.realHome : inCwd && dirname(realCwd) !== realCwd ? realCwd : null;
+            if (!root || shouldIgnore(root, real, denyRules))
+                continue;
             if (inCwd) {
                 let rules = ctx.cwdRules.get(realCwd);
                 if (!rules)

package/dist/lib/transcripts/codex.js

@@ -1,7 +1,8 @@
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
+import { codexHome } from '../config.js';
 import { DocBuilder, asObj, asStr, jsonLines, mtimeOf, patchPaths, readText, toolSummary } from './util.js';
-// Codex CLI: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl, with
+// Codex CLI: $CODEX_HOME (default ~/.codex)/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl, with
 // older rollouts zstd-compressed to .jsonl.zst. Lines are
 // `{ timestamp, type, payload }`: session_meta (id, cwd), response_item
 // (message | function_call | custom_tool_call), and event_msg
@@ -46,9 +47,9 @@ function parseArgs(raw) {
 }
 export const codexSource = {
     platform: 'codex',
-    async enumerate({ home, since }) {
+    async enumerate({ home, since, env }) {
         const byId = new Map();
-        for (const path of await walkRollouts(join(home, '.codex', 'sessions'))) {
+        for (const path of await walkRollouts(join(codexHome(env, home), 'sessions'))) {
             const mtime = await mtimeOf(path);
             if (!mtime || (since && mtime <= since))
                 continue;

package/dist/lib/transcripts/opencode.js

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
-import { DocBuilder, asObj, asStr, patchPaths, toolSummary } from './util.js';
+import { opencodeDataDir } from '../config.js';
+import { DocBuilder, asObj, asStr, mtimeOf, 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)));
@@ -32,7 +33,10 @@ export function createOpencodeSource(exec = defaultExec) {
         // 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 }) {
+        async enumerate({ home, since, cwd, env }) {
+            // Without a data dir OpenCode was never used, and the CLI would cost up to 15s and create its config dir.
+            if (!(await mtimeOf(opencodeDataDir(env, home))))
+                return [];
             let list;
             try {
                 list = parseJson(await exec(['session', 'list', '--format', 'json'], cwd));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adrive/cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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",
@@ -14,13 +14,8 @@
     "LICENSE"
   ],
   "homepage": "https://agentdrive.sh",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Rakesh1002/agentdrive.git",
-    "directory": "packages/cli"
-  },
   "bugs": {
-    "url": "https://github.com/Rakesh1002/agentdrive/issues"
+    "url": "https://github.com/Rakesh1002/agentdrive-mcp/issues"
   },
   "keywords": [
     "agentdrive",
@@ -43,7 +38,7 @@
     "kleur": "^4.1.5",
     "open": "^10.1.0",
     "prompts": "^2.4.2",
-    "@adrive/mcp-server": "^1.1.0"
+    "@adrive/mcp-server": "^1.1.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",