@adrive/cli 0.1.0

package/dist/commands/search.js

@@ -0,0 +1,37 @@
+import kleur from 'kleur';
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+function truncate(s, n) {
+    if (!s)
+        return '';
+    return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
+}
+export async function cmdSearch(query, 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 topK = opts.topK ? Number.parseInt(opts.topK, 10) : undefined;
+    const filter = {};
+    if (opts.platform)
+        filter.agent_platform = opts.platform;
+    const res = await client.search({
+        query,
+        workspace_id: opts.workspace ?? cfg.default_workspace,
+        top_k: topK,
+        filter: Object.keys(filter).length ? filter : undefined,
+    });
+    if (!res.hits.length) {
+        process.stdout.write('No results.\n');
+        return;
+    }
+    for (const h of res.hits) {
+        const score = h.score.toFixed(2);
+        process.stdout.write(`${kleur.cyan(h.path)} · score=${score} · by=${h.agent_id}@${h.agent_platform}\n`);
+        if (h.snippet)
+            process.stdout.write(`  ${kleur.dim(truncate(h.snippet, 200))}\n`);
+    }
+}

package/dist/commands/whoami.js

@@ -0,0 +1,13 @@
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+export async function cmdWhoami() {
+    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 info = await client.whoami();
+    process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
+}

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import kleur from 'kleur';
+import { cmdInit } from './commands/init.js';
+import { cmdAuthLogin } from './commands/auth-login.js';
+import { cmdAuthLogout } from './commands/auth-logout.js';
+import { cmdAuthStatus } from './commands/auth-status.js';
+import { cmdWhoami } from './commands/whoami.js';
+import { cmdLs } from './commands/ls.js';
+import { cmdPush } from './commands/push.js';
+import { cmdPull } from './commands/pull.js';
+import { cmdSearch } from './commands/search.js';
+import { cmdContext } from './commands/context.js';
+import { cmdRunLog } from './commands/run-log.js';
+import { cmdBilling } from './commands/billing.js';
+import { cmdPlan } from './commands/plan.js';
+const VERSION = '0.1.0';
+function fail(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${kleur.red('[error]')} ${msg}\n`);
+    process.exit(1);
+}
+function wrap(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (err) {
+            fail(err);
+        }
+    };
+}
+process.on('SIGINT', () => {
+    process.stderr.write('\nInterrupted.\n');
+    process.exit(130);
+});
+const program = new Command();
+program
+    .name('adrive')
+    .description('AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph.')
+    .version(VERSION, '-v, --version');
+program
+    .command('init')
+    .description('First-run wizard: log in and wire AgentDrive into installed agent tools')
+    .option('-y, --yes', 'Skip prompts and accept defaults')
+    .option('--api-url <url>', 'Override the AgentDrive API base URL')
+    .action(wrap((opts) => cmdInit(opts)));
+const auth = program.command('auth').description('Manage AgentDrive login');
+auth
+    .command('login')
+    .description('Open browser, log in, store API key')
+    .option('--api-url <url>', 'Override the AgentDrive API base URL')
+    .action(wrap((opts) => cmdAuthLogin(opts)));
+auth
+    .command('logout')
+    .description('Wipe local AgentDrive credentials')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(wrap((opts) => cmdAuthLogout(opts)));
+auth
+    .command('status')
+    .description('Show current login state')
+    .action(wrap(() => cmdAuthStatus()));
+program
+    .command('whoami')
+    .description('Print principal info from the AgentDrive API')
+    .action(wrap(() => cmdWhoami()));
+program
+    .command('ls')
+    .description('List workspaces')
+    .action(wrap(() => cmdLs()));
+program
+    .command('push <local-path>')
+    .description('Upload a local file to a workspace')
+    .option('-w, --workspace <id>', 'Workspace id (default: only workspace, if exactly one)')
+    .option('-r, --remote-path <path>', 'Remote path (default: basename of local-path)')
+    .option('-m, --message <msg>', 'Commit-style message stored on the version')
+    .action(wrap((localPath, opts) => cmdPush(localPath, opts)));
+program
+    .command('pull <workspace-id-slash-path>')
+    .description('Download a file. Spec is <workspace-id>/<path>')
+    .option('-o, --out <file>', 'Write to file (default: stdout)')
+    .action(wrap((spec, opts) => cmdPull(spec, opts)));
+program
+    .command('search <query>')
+    .description('Semantic search across workspace artifacts')
+    .option('--top-k <n>', 'Number of hits to return')
+    .option('--platform <p>', 'Filter to artifacts written by a specific agent platform')
+    .option('-w, --workspace <id>', 'Restrict to one workspace')
+    .action(wrap((query, opts) => cmdSearch(query, {
+    topK: opts.topK,
+    platform: opts.platform,
+    workspace: opts.workspace,
+})));
+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')
+    .action(wrap((task, opts) => cmdContext(task, opts)));
+program
+    .command('run-log <task>')
+    .description('Log an agent run for cross-platform provenance')
+    .option('--status <status>', 'success | failure | partial | in_progress', 'success')
+    .option('--duration <ms>', 'Duration in milliseconds')
+    .option('--ref <path...>', 'Artifacts referenced (repeatable)')
+    .option('--produced <path...>', 'Artifacts produced (repeatable)')
+    .action(wrap((task, opts) => cmdRunLog(task, {
+    status: opts.status,
+    duration: opts.duration,
+    ref: opts.ref,
+    produced: opts.produced,
+})));
+program
+    .command('billing')
+    .description('Open the Stripe billing portal in your browser')
+    .action(wrap(() => cmdBilling()));
+program
+    .command('plan')
+    .description('Show current plan, usage, and quotas')
+    .action(wrap(() => cmdPlan()));
+program.parseAsync(process.argv).catch(fail);

package/dist/lib/api-client.js

@@ -0,0 +1,122 @@
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+export class CliApiClient {
+    baseUrl;
+    apiKey;
+    agentPlatform;
+    agentRole;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+        this.agentPlatform = config.agentPlatform ?? 'cli';
+        this.agentRole = config.agentRole ?? '';
+    }
+    headers(authRequired) {
+        const h = {
+            'Content-Type': 'application/json',
+            'X-Agent-Platform': this.agentPlatform,
+            'X-Agent-Role': this.agentRole,
+        };
+        if (authRequired && this.apiKey) {
+            h['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        return h;
+    }
+    async request(method, path, body, authRequired = true) {
+        const url = `${this.baseUrl}/v1${path}`;
+        const res = await fetch(url, {
+            method,
+            headers: this.headers(authRequired),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        let json;
+        try {
+            json = await res.json();
+        }
+        catch {
+            throw new ApiError(`Invalid JSON response (status ${res.status})`, res.status);
+        }
+        if (!res.ok || !json.success) {
+            throw new ApiError(json.error ?? `Request failed (${res.status})`, res.status);
+        }
+        return json.data;
+    }
+    async requestPage(method, path, body) {
+        const url = `${this.baseUrl}/v1${path}`;
+        const res = await fetch(url, {
+            method,
+            headers: this.headers(true),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        if (!res.ok || !json.success) {
+            throw new ApiError(json.error ?? `Request failed (${res.status})`, res.status);
+        }
+        return { items: (json.data ?? []), cursor: json.cursor ?? null };
+    }
+    async startCliAuth() {
+        return this.request('POST', '/auth/cli/start', {}, false);
+    }
+    async pollCliAuth(id) {
+        return this.request('GET', `/auth/cli/poll?id=${encodeURIComponent(id)}`, undefined, false);
+    }
+    async getAuthProviders() {
+        return this.request('GET', '/auth/providers', undefined, false);
+    }
+    async whoami() {
+        // /v1/auth/me is the canonical principal endpoint; fall back to /v1/org if the worker hasn't shipped it.
+        try {
+            return await this.request('GET', '/auth/me');
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.status === 404) {
+                return await this.request('GET', '/org');
+            }
+            throw err;
+        }
+    }
+    async listWorkspaces() {
+        const all = [];
+        let cursor = null;
+        for (let i = 0; i < 20; i++) {
+            const url = cursor ? `/workspaces?cursor=${encodeURIComponent(cursor)}` : '/workspaces';
+            const page = await this.requestPage('GET', url);
+            all.push(...page.items);
+            if (!page.cursor)
+                return all;
+            cursor = page.cursor;
+        }
+        return all;
+    }
+    async writeFile(workspaceId, path, content, message) {
+        return this.request('POST', `/workspaces/${workspaceId}/files`, { path, content, message });
+    }
+    async readFileByPath(workspaceId, path) {
+        const files = await this.requestPage('GET', `/workspaces/${workspaceId}/files?prefix=${encodeURIComponent(path)}`);
+        const match = files.items.find((f) => f.path === path) ?? files.items[0];
+        if (!match)
+            throw new ApiError(`File not found: ${path}`, 404);
+        return this.request('GET', `/workspaces/${workspaceId}/files/${match.id}?content=true`);
+    }
+    async search(body) {
+        return this.request('POST', '/search', body);
+    }
+    async context(body) {
+        return this.request('POST', '/context', body);
+    }
+    async logRun(body) {
+        return this.request('POST', '/runs', body);
+    }
+    async billingPortal() {
+        return this.request('POST', '/billing/portal', {});
+    }
+    async billingPlan() {
+        return this.request('GET', '/billing/plan');
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,65 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export const DEFAULT_API_URL = 'https://app.agentdrive.sh';
+export function configDir(env = process.env, home = homedir()) {
+    const xdg = env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : join(home, '.config');
+    return join(base, 'agentdrive');
+}
+export function configPath(env = process.env, home = homedir()) {
+    return join(configDir(env, home), 'config.json');
+}
+export async function readConfig(path = configPath()) {
+    try {
+        const raw = await fs.readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return {
+            api_url: parsed.api_url ?? DEFAULT_API_URL,
+            api_key: parsed.api_key,
+            agent_id: parsed.agent_id,
+            org_id: parsed.org_id,
+            agent_platform: parsed.agent_platform ?? 'cli',
+            agent_role: parsed.agent_role,
+            default_workspace: parsed.default_workspace,
+        };
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+export async function writeConfig(config, path = configPath()) {
+    await fs.mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const payload = JSON.stringify(config, null, 2);
+    await fs.writeFile(path, payload, { encoding: 'utf8', mode: 0o600 });
+    try {
+        await fs.chmod(path, 0o600);
+    }
+    catch {
+        // chmod can fail on non-POSIX; permissions already set via writeFile mode.
+    }
+}
+export async function deleteConfig(path = configPath()) {
+    try {
+        await fs.unlink(path);
+        return true;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+export async function requireLogin(path = configPath()) {
+    const c = await readConfig(path);
+    if (!c || !c.api_key) {
+        throw new Error('Not logged in. Run `adrive auth login` first.');
+    }
+    return c;
+}

package/dist/lib/detect-agents.js

@@ -0,0 +1,223 @@
+import { promises as fs } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { dirname, join } from 'node:path';
+export function getAgentTargets(opts = {}) {
+    const env = opts.env ?? process.env;
+    const home = opts.home ?? homedir();
+    const os = opts.osPlatform ?? platform();
+    const claudeDesktop = os === 'darwin'
+        ? join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+        : os === 'win32'
+            ? join(env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json')
+            : join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    return [
+        {
+            name: 'claude-code',
+            configPath: join(home, '.claude', 'mcp-servers.json'),
+            format: 'mcp-json',
+            defaultPlatform: 'claude-code',
+        },
+        {
+            name: 'claude-desktop',
+            configPath: claudeDesktop,
+            format: 'mcp-json',
+            defaultPlatform: 'claude-code',
+        },
+        {
+            name: 'codex',
+            configPath: join(home, '.codex', 'config.toml'),
+            format: 'codex-toml',
+            defaultPlatform: 'codex',
+        },
+        {
+            name: 'cursor',
+            configPath: join(home, '.cursor', 'mcp.json'),
+            format: 'cursor-json',
+            defaultPlatform: 'cursor',
+        },
+        {
+            name: 'continue',
+            configPath: join(home, '.continue', 'config.json'),
+            format: 'continue-json',
+            defaultPlatform: 'continue',
+        },
+        {
+            name: 'zed',
+            configPath: os === 'darwin'
+                ? join(home, '.config', 'zed', 'settings.json')
+                : join(home, '.config', 'zed', 'settings.json'),
+            format: 'zed-json',
+            defaultPlatform: 'zed',
+        },
+        {
+            name: 'cline',
+            configPath: os === 'darwin'
+                ? join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json')
+                : join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+            format: 'mcp-json',
+            defaultPlatform: 'cline',
+        },
+    ];
+}
+async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonSafe(path) {
+    try {
+        const raw = await fs.readFile(path, 'utf8');
+        if (!raw.trim())
+            return {};
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return null;
+        return null;
+    }
+}
+function mcpEntry(env, platformOverride) {
+    const envBlock = {
+        AGENTDRIVE_API_KEY: env.apiKey,
+    };
+    if (env.apiUrl)
+        envBlock.AGENTDRIVE_API_URL = env.apiUrl;
+    const plat = env.agentPlatform ?? platformOverride;
+    if (plat)
+        envBlock.AGENTDRIVE_AGENT_PLATFORM = plat;
+    return {
+        command: 'npx',
+        args: ['-y', '@adrive/mcp-server'],
+        env: envBlock,
+    };
+}
+export function mergeMcpJson(existing, env, platformOverride) {
+    const base = existing && typeof existing === 'object' ? { ...existing } : {};
+    const serversRaw = base.mcpServers;
+    const servers = serversRaw && typeof serversRaw === 'object' && !Array.isArray(serversRaw)
+        ? { ...serversRaw }
+        : {};
+    servers.agentdrive = mcpEntry(env, platformOverride);
+    base.mcpServers = servers;
+    return base;
+}
+export function mergeCursorJson(existing, env) {
+    return mergeMcpJson(existing, env, 'cursor');
+}
+export function mergeContinueJson(existing, env) {
+    const base = existing && typeof existing === 'object' ? { ...existing } : {};
+    const rawList = base.mcpServers;
+    const list = Array.isArray(rawList) ? [...rawList] : [];
+    const filtered = list.filter((s) => {
+        if (!s || typeof s !== 'object')
+            return true;
+        return s.name !== 'agentdrive';
+    });
+    filtered.push({
+        name: 'agentdrive',
+        ...mcpEntry(env, 'continue'),
+    });
+    base.mcpServers = filtered;
+    return base;
+}
+export function mergeZedJson(existing, env) {
+    const base = existing && typeof existing === 'object' ? { ...existing } : {};
+    const ctxRaw = base.context_servers;
+    const ctx = ctxRaw && typeof ctxRaw === 'object' && !Array.isArray(ctxRaw)
+        ? { ...ctxRaw }
+        : {};
+    ctx.agentdrive = mcpEntry(env, 'zed');
+    base.context_servers = ctx;
+    return base;
+}
+export function mergeCodexToml(existing, env) {
+    const blockHeader = '[[mcp_servers]]';
+    const target = 'name = "agentdrive"';
+    const apiKey = env.apiKey.replace(/"/g, '\\"');
+    const apiUrlLine = env.apiUrl ? `, AGENTDRIVE_API_URL = "${env.apiUrl}"` : '';
+    const newBlock = `${blockHeader}\nname = "agentdrive"\ncommand = "npx"\nargs = ["-y", "@adrive/mcp-server"]\n` +
+        `env = { AGENTDRIVE_API_KEY = "${apiKey}", AGENTDRIVE_AGENT_PLATFORM = "codex"${apiUrlLine} }\n`;
+    const trimmed = existing.trimEnd();
+    if (!trimmed)
+        return newBlock;
+    if (!trimmed.includes(target)) {
+        return `${trimmed}\n\n${newBlock}`;
+    }
+    // Replace the existing agentdrive block in place: scan blocks, swap the matching one.
+    const blocks = trimmed.split(/(?=^\[\[mcp_servers\]\]$)/m);
+    const updated = blocks.map((block) => {
+        if (block.includes(target))
+            return newBlock.trimEnd();
+        return block.trimEnd();
+    });
+    return `${updated.join('\n\n')}\n`;
+}
+export async function wireAgent(target, env, opts = {}) {
+    const exists = await fileExists(target.configPath);
+    if (!exists && !opts.writeIfMissing) {
+        throw new Error(`Config not found: ${target.configPath}`);
+    }
+    await fs.mkdir(dirname(target.configPath), { recursive: true });
+    if (target.format === 'codex-toml') {
+        const existing = exists ? await fs.readFile(target.configPath, 'utf8') : '';
+        const merged = mergeCodexToml(existing, env);
+        await fs.writeFile(target.configPath, merged, 'utf8');
+        return;
+    }
+    const existing = exists ? await readJsonSafe(target.configPath) : {};
+    let merged;
+    switch (target.format) {
+        case 'mcp-json':
+            merged = mergeMcpJson(existing, env, target.defaultPlatform);
+            break;
+        case 'cursor-json':
+            merged = mergeCursorJson(existing, env);
+            break;
+        case 'continue-json':
+            merged = mergeContinueJson(existing, env);
+            break;
+        case 'zed-json':
+            merged = mergeZedJson(existing, env);
+            break;
+        default:
+            throw new Error(`Unknown format: ${String(target.format)}`);
+    }
+    await fs.writeFile(target.configPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+}
+export async function detectInstalledAgents(opts = {}) {
+    const targets = getAgentTargets(opts);
+    const present = [];
+    for (const t of targets) {
+        if (await fileExists(t.configPath))
+            present.push(t);
+    }
+    return present;
+}
+export async function wireAllInstalled(env, opts = {}) {
+    const all = getAgentTargets(opts);
+    const wired = [];
+    const skipped = [];
+    for (const t of all) {
+        const exists = await fileExists(t.configPath);
+        const forceWrite = opts.includeMissing?.includes(t.name) ?? false;
+        if (!exists && !forceWrite) {
+            skipped.push({ name: t.name, reason: 'config not found' });
+            continue;
+        }
+        try {
+            await wireAgent(t, env, { writeIfMissing: forceWrite });
+            wired.push(t.name);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            skipped.push({ name: t.name, reason: msg });
+        }
+    }
+    return { wired, skipped };
+}

package/dist/lib/poll-auth.js

@@ -0,0 +1,57 @@
+import open from 'open';
+import kleur from 'kleur';
+const SPINNER_FRAMES = ['|', '/', '-', '\\'];
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function pollAuth(client, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 1500;
+    const timeoutMs = options.timeoutMs ?? 10 * 60 * 1000;
+    const log = options.log ?? ((line) => process.stdout.write(`${line}\n`));
+    const sleep = options.sleep ?? defaultSleep;
+    const browserOpener = options.openBrowser ?? ((url) => open(url));
+    const start = await client.startCliAuth();
+    log(kleur.bold('Opening browser to log in...'));
+    log(`  ${kleur.cyan(start.auth_url)}`);
+    log('  If the browser does not open, copy and paste the URL above.');
+    try {
+        await browserOpener(start.auth_url);
+    }
+    catch {
+        log(kleur.yellow('[warn] Could not auto-open browser. Use the URL above.'));
+    }
+    const deadline = Date.now() + timeoutMs;
+    let frame = 0;
+    const showSpinner = options.spinner !== false && process.stdout.isTTY;
+    while (Date.now() < deadline) {
+        let poll;
+        try {
+            poll = await client.pollCliAuth(start.id);
+        }
+        catch (err) {
+            if (showSpinner)
+                process.stdout.write('\r');
+            throw err;
+        }
+        if (poll.status === 'complete') {
+            if (showSpinner)
+                process.stdout.write('\r');
+            log(kleur.green('[ok] Logged in.'));
+            return {
+                api_key: poll.api_key,
+                agent_id: poll.agent_id,
+                org_id: poll.org_id,
+                session_token: poll.session_token,
+            };
+        }
+        if (showSpinner) {
+            const f = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+            frame += 1;
+            process.stdout.write(`\r${kleur.dim(`[wait] ${f} polling for login...`)}`);
+        }
+        await sleep(pollIntervalMs);
+    }
+    if (showSpinner)
+        process.stdout.write('\r');
+    throw new Error('Login timed out. Run `adrive auth login` again.');
+}