@agi-cli/sdk 0.1.53 → 0.1.55

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.53",
+	"version": "0.1.55",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "ntishxyz",
 	"license": "MIT",
@@ -16,46 +16,70 @@
 	"type": "module",
 	"main": "./src/index.ts",
 	"types": "./src/index.ts",
-	"files": [
-		"src",
-		"README.md",
-		"LICENSE"
-	],
 	"exports": {
 		".": {
 			"import": "./src/index.ts",
 			"types": "./src/index.ts"
 		},
 		"./tools/builtin/fs": {
-			"import": "./src/tools/builtin/fs.ts",
-			"types": "./src/tools/builtin/fs.ts"
+			"import": "./src/core/src/tools/builtin/fs/index.ts",
+			"types": "./src/core/src/tools/builtin/fs/index.ts"
 		},
 		"./tools/builtin/git": {
-			"import": "./src/tools/builtin/git.ts",
-			"types": "./src/tools/builtin/git.ts"
+			"import": "./src/core/src/tools/builtin/git.ts",
+			"types": "./src/core/src/tools/builtin/git.ts"
+		},
+		"./tools/builtin/bash": {
+			"import": "./src/core/src/tools/builtin/bash.ts",
+			"types": "./src/core/src/tools/builtin/bash.ts"
+		},
+		"./tools/builtin/edit": {
+			"import": "./src/core/src/tools/builtin/edit.ts",
+			"types": "./src/core/src/tools/builtin/edit.ts"
+		},
+		"./tools/builtin/finish": {
+			"import": "./src/core/src/tools/builtin/finish.ts",
+			"types": "./src/core/src/tools/builtin/finish.ts"
+		},
+		"./tools/builtin/grep": {
+			"import": "./src/core/src/tools/builtin/grep.ts",
+			"types": "./src/core/src/tools/builtin/grep.ts"
+		},
+		"./tools/builtin/patch": {
+			"import": "./src/core/src/tools/builtin/patch.ts",
+			"types": "./src/core/src/tools/builtin/patch.ts"
 		},
-		"./web-ui": {
-			"import": "./src/web-ui.ts",
-			"types": "./src/web-ui.ts"
-		}
+		"./tools/builtin/plan": {
+			"import": "./src/core/src/tools/builtin/plan.ts",
+			"types": "./src/core/src/tools/builtin/plan.ts"
+		},
+		"./tools/builtin/progress": {
+			"import": "./src/core/src/tools/builtin/progress.ts",
+			"types": "./src/core/src/tools/builtin/progress.ts"
+		},
+		"./tools/builtin/ripgrep": {
+			"import": "./src/core/src/tools/builtin/ripgrep.ts",
+			"types": "./src/core/src/tools/builtin/ripgrep.ts"
+		},
+		"./tools/builtin/websearch": {
+			"import": "./src/core/src/tools/builtin/websearch.ts",
+			"types": "./src/core/src/tools/builtin/websearch.ts"
+		},
+		"./prompts/*": "./src/prompts/src/*"
 	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
 	"scripts": {
 		"dev": "bun run src/index.ts",
-		"build": "bun run build.ts",
 		"test": "bun test",
-		"typecheck": "tsc --noEmit",
-		"prepublishOnly": "bun run build"
+		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/auth": "0.1.0",
-		"@agi-cli/config": "0.1.0",
-		"@agi-cli/core": "0.1.0",
-		"@agi-cli/database": "0.1.0",
-		"@agi-cli/web-ui": "0.1.53",
-		"@agi-cli/providers": "0.1.0",
-		"@agi-cli/prompts": "0.1.0",
-		"@agi-cli/server": "0.1.0",
-		"@agi-cli/types": "0.1.0",
+		"@openauthjs/openauth": "^0.4.3",
+		"opencode-anthropic-auth": "^0.0.2",
 		"ai": "^5.0.43",
 		"@ai-sdk/anthropic": "^2.0.16",
 		"@ai-sdk/openai": "^2.0.30",
@@ -63,7 +87,8 @@
 		"@openrouter/ai-sdk-provider": "^1.2.0",
 		"@ai-sdk/openai-compatible": "^1.0.18",
 		"hono": "^4.9.7",
-		"zod": "^4.1.8"
+		"zod": "^4.1.8",
+		"fast-glob": "^3.3.2"
 	},
 	"devDependencies": {
 		"@types/bun": "latest",

package/src/agent/types.ts

@@ -1,4 +1,4 @@
-import type { ProviderName } from '@agi-cli/core';
+import type { ProviderName } from '../core/src/index.ts';
 
 export type AgentConfig = {
 	name: string;

package/src/auth/src/index.ts

@@ -0,0 +1,70 @@
+import { getSecureAuthPath, ensureDir } from '../../config/src/paths.ts';
+import type { ProviderId, AuthInfo, AuthFile } from '../../types/src/index.ts';
+
+export type {
+	ProviderId,
+	ApiAuth,
+	OAuth,
+	AuthInfo,
+} from '../../types/src/index.ts';
+
+function globalAuthPath(): string {
+	return getSecureAuthPath();
+}
+
+export async function getAllAuth(_projectRoot?: string): Promise<AuthFile> {
+	const globalFile = Bun.file(globalAuthPath());
+	const globalData = (await globalFile.json().catch(() => ({}))) as AuthFile;
+	return { ...globalData };
+}
+
+export async function getAuth(
+	provider: ProviderId,
+	projectRoot?: string,
+): Promise<AuthInfo | undefined> {
+	const all = await getAllAuth(projectRoot);
+	return all[provider];
+}
+
+export async function setAuth(
+	provider: ProviderId,
+	info: AuthInfo,
+	_projectRoot?: string,
+	_scope: 'global' | 'local' = 'global',
+) {
+	const path = globalAuthPath();
+	const f = Bun.file(path);
+	const existing = ((await f.json().catch(() => ({}))) || {}) as AuthFile;
+	const next: AuthFile = { ...existing, [provider]: info };
+	const base = path.slice(0, path.lastIndexOf('/')) || '.';
+	await ensureDir(base);
+	await Bun.write(path, JSON.stringify(next, null, 2));
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.chmod(path, 0o600).catch(() => {});
+	} catch {}
+}
+
+export async function removeAuth(
+	provider: ProviderId,
+	_projectRoot?: string,
+	_scope: 'global' | 'local' = 'global',
+) {
+	const path = globalAuthPath();
+	const f = Bun.file(path);
+	const existing = ((await f.json().catch(() => ({}))) || {}) as AuthFile;
+	delete existing[provider];
+	await Bun.write(path, JSON.stringify(existing, null, 2));
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.chmod(path, 0o600).catch(() => {});
+	} catch {}
+}
+
+export {
+	authorize,
+	exchange,
+	refreshToken,
+	openAuthUrl,
+	createApiKey,
+} from './oauth.ts';

package/src/auth/src/oauth.ts

@@ -0,0 +1,172 @@
+import { spawn } from 'node:child_process';
+import { randomBytes, createHash } from 'node:crypto';
+
+const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+
+type Mode = 'max' | 'console';
+
+// Custom PKCE implementation using synchronous crypto
+function generatePKCE() {
+	// Generate random verifier (43-128 characters, base64url encoded)
+	const verifier = randomBytes(32)
+		.toString('base64')
+		.replace(/\+/g, '-')
+		.replace(/\//g, '_')
+		.replace(/=/g, '');
+
+	// Generate challenge from verifier (SHA-256 hash, base64url encoded)
+	const challenge = createHash('sha256')
+		.update(verifier)
+		.digest('base64')
+		.replace(/\+/g, '-')
+		.replace(/\//g, '_')
+		.replace(/=/g, '');
+
+	return { verifier, challenge };
+}
+
+async function openBrowser(url: string) {
+	const platform = process.platform;
+	let command: string;
+
+	switch (platform) {
+		case 'darwin':
+			command = `open "${url}"`;
+			break;
+		case 'win32':
+			command = `start "${url}"`;
+			break;
+		default:
+			command = `xdg-open "${url}"`;
+			break;
+	}
+
+	return new Promise<void>((resolve, reject) => {
+		const child = spawn(command, [], { shell: true });
+		child.on('error', reject);
+		child.on('exit', (code) => {
+			if (code === 0) resolve();
+			else reject(new Error(`Failed to open browser (exit code ${code})`));
+		});
+	});
+}
+
+export async function authorize(mode: Mode) {
+	const pkce = generatePKCE();
+
+	const url = new URL(
+		`https://${mode === 'console' ? 'console.anthropic.com' : 'claude.ai'}/oauth/authorize`,
+	);
+	url.searchParams.set('code', 'true');
+	url.searchParams.set('client_id', CLIENT_ID);
+	url.searchParams.set('response_type', 'code');
+	url.searchParams.set(
+		'redirect_uri',
+		'https://console.anthropic.com/oauth/code/callback',
+	);
+	url.searchParams.set(
+		'scope',
+		'org:create_api_key user:profile user:inference',
+	);
+	url.searchParams.set('code_challenge', pkce.challenge);
+	url.searchParams.set('code_challenge_method', 'S256');
+	url.searchParams.set('state', pkce.verifier);
+
+	return {
+		url: url.toString(),
+		verifier: pkce.verifier,
+	};
+}
+
+export async function exchange(code: string, verifier: string) {
+	const splits = code.split('#');
+	const result = await fetch('https://console.anthropic.com/v1/oauth/token', {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify({
+			code: splits[0],
+			state: splits[1],
+			grant_type: 'authorization_code',
+			client_id: CLIENT_ID,
+			redirect_uri: 'https://console.anthropic.com/oauth/code/callback',
+			code_verifier: verifier,
+		}),
+	});
+
+	if (!result.ok) {
+		const error = await result.text();
+		throw new Error(`Token exchange failed: ${error}`);
+	}
+
+	const json = (await result.json()) as {
+		refresh_token: string;
+		access_token: string;
+		expires_in: number;
+	};
+	return {
+		refresh: json.refresh_token,
+		access: json.access_token,
+		expires: Date.now() + json.expires_in * 1000,
+	};
+}
+
+export async function refreshToken(refreshToken: string) {
+	const response = await fetch('https://console.anthropic.com/v1/oauth/token', {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify({
+			grant_type: 'refresh_token',
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID,
+		}),
+	});
+
+	if (!response.ok) {
+		throw new Error('Failed to refresh token');
+	}
+
+	const json = (await response.json()) as {
+		refresh_token: string;
+		access_token: string;
+		expires_in: number;
+	};
+	return {
+		refresh: json.refresh_token,
+		access: json.access_token,
+		expires: Date.now() + json.expires_in * 1000,
+	};
+}
+
+export async function openAuthUrl(url: string) {
+	try {
+		await openBrowser(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function createApiKey(accessToken: string) {
+	const result = await fetch(
+		'https://api.anthropic.com/api/oauth/claude_cli/create_api_key',
+		{
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				authorization: `Bearer ${accessToken}`,
+			},
+		},
+	);
+
+	if (!result.ok) {
+		const error = await result.text();
+		throw new Error(`Failed to create API key: ${error}`);
+	}
+
+	const json = (await result.json()) as { raw_key: string };
+	return json.raw_key;
+}

package/src/config/src/index.ts

@@ -0,0 +1,120 @@
+import {
+	getGlobalConfigPath,
+	getLocalDataDir,
+	ensureDir,
+	fileExists,
+	joinPath,
+} from './paths.ts';
+import type { AGIConfig } from '../../types/src/index.ts';
+
+export type { ProviderConfig, AGIConfig } from '../../types/src/index.ts';
+
+const DEFAULTS: {
+	defaults: AGIConfig['defaults'];
+	providers: AGIConfig['providers'];
+} = {
+	defaults: {
+		agent: 'general',
+		provider: 'openai',
+		model: 'gpt-4o-mini',
+	},
+	providers: {
+		openai: { enabled: true },
+		anthropic: { enabled: true },
+		google: { enabled: true },
+		openrouter: { enabled: false },
+		opencode: { enabled: false },
+	},
+};
+
+export async function loadConfig(
+	projectRootInput?: string,
+): Promise<AGIConfig> {
+	const projectRoot = projectRootInput
+		? String(projectRootInput)
+		: process.cwd();
+
+	const dataDir = getLocalDataDir(projectRoot);
+	const dbPath = joinPath(dataDir, 'agi.sqlite');
+	const projectConfigPath = joinPath(dataDir, 'config.json');
+	const globalConfigPath = getGlobalConfigPath();
+
+	const projectCfg = await readJsonOptional(projectConfigPath);
+	const globalCfg = await readJsonOptional(globalConfigPath);
+
+	const merged = deepMerge(DEFAULTS, globalCfg, projectCfg);
+
+	await ensureDir(dataDir);
+
+	return {
+		projectRoot,
+		defaults: merged.defaults as AGIConfig['defaults'],
+		providers: merged.providers as AGIConfig['providers'],
+		paths: {
+			dataDir,
+			dbPath,
+			projectConfigPath: (await fileExists(projectConfigPath))
+				? projectConfigPath
+				: null,
+			globalConfigPath: (await fileExists(globalConfigPath))
+				? globalConfigPath
+				: null,
+		},
+	} satisfies AGIConfig;
+}
+
+type JsonObject = Record<string, unknown>;
+
+async function readJsonOptional(file: string): Promise<JsonObject | undefined> {
+	const f = Bun.file(file);
+	if (!(await f.exists())) return undefined;
+	try {
+		const buf = await f.text();
+		const parsed = JSON.parse(buf);
+		if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+			return parsed as JsonObject;
+		}
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function deepMerge<T extends JsonObject>(
+	...objects: Array<JsonObject | undefined>
+): T {
+	const result: JsonObject = {};
+	for (const obj of objects) {
+		if (!obj) continue;
+		mergeInto(result, obj);
+	}
+	return result as T;
+}
+
+function mergeInto(target: JsonObject, source: JsonObject): JsonObject {
+	for (const key of Object.keys(source)) {
+		const sv = source[key];
+		const tv = target[key];
+		if (sv && typeof sv === 'object' && !Array.isArray(sv)) {
+			const svObj = sv as JsonObject;
+			const nextTarget =
+				tv && typeof tv === 'object' && !Array.isArray(tv)
+					? (tv as JsonObject)
+					: {};
+			target[key] = mergeInto(nextTarget, svObj);
+		} else {
+			target[key] = sv;
+		}
+	}
+	return target;
+}
+
+export type { Scope } from './manager.ts';
+export {
+	read,
+	isAuthorized,
+	ensureEnv,
+	writeDefaults,
+	writeAuth,
+	removeAuth,
+} from './manager.ts';

package/src/config/src/manager.ts

@@ -0,0 +1,102 @@
+import { loadConfig } from './index.ts';
+import {
+	getAllAuth,
+	setAuth as setAuthFile,
+	removeAuth as removeAuthFile,
+	type ProviderId,
+	type AuthInfo,
+} from '../../auth/src/index.ts';
+import { getGlobalConfigDir, getGlobalConfigPath } from './paths.ts';
+import {
+	providerIds,
+	readEnvKey,
+	setEnvKey,
+} from '../../providers/src/index.ts';
+
+export type Scope = 'global' | 'local';
+
+export async function read(projectRoot?: string) {
+	const cfg = await loadConfig(projectRoot);
+	const auth = await getAllAuth(projectRoot);
+	return { cfg, auth };
+}
+
+export async function isAuthorized(
+	provider: ProviderId,
+	projectRoot?: string,
+): Promise<boolean> {
+	if (!providerIds.includes(provider)) return false;
+	if (readEnvKey(provider)) return true;
+	const { auth } = await read(projectRoot);
+	const info = auth[provider];
+	if (info?.type === 'api' && info.key) return true;
+	if (info?.type === 'oauth' && info.refresh && info.access) return true;
+	return false;
+}
+
+export async function ensureEnv(
+	provider: ProviderId,
+	projectRoot?: string,
+): Promise<void> {
+	if (!providerIds.includes(provider)) return;
+	if (readEnvKey(provider)) return;
+	const { auth } = await read(projectRoot);
+	const stored = auth[provider];
+	const key = stored?.type === 'api' ? stored.key : undefined;
+	if (key) setEnvKey(provider, key);
+}
+
+export async function writeDefaults(
+	scope: Scope,
+	updates: Partial<{ agent: string; provider: ProviderId; model: string }>,
+	projectRoot?: string,
+) {
+	const { cfg } = await read(projectRoot);
+	if (scope === 'local') {
+		const next = {
+			projectRoot: cfg.projectRoot,
+			defaults: {
+				agent: updates.agent ?? cfg.defaults.agent,
+				provider: (updates.provider ?? cfg.defaults.provider) as ProviderId,
+				model: updates.model ?? cfg.defaults.model,
+			},
+			providers: cfg.providers,
+			paths: cfg.paths,
+		};
+		const path = `${cfg.paths.dataDir}/config.json`;
+		await Bun.write(path, JSON.stringify(next, null, 2));
+		return;
+	}
+	const base = getGlobalConfigDir();
+	const path = getGlobalConfigPath();
+	const next = {
+		defaults: {
+			agent: updates.agent ?? cfg.defaults.agent,
+			provider: (updates.provider ?? cfg.defaults.provider) as ProviderId,
+			model: updates.model ?? cfg.defaults.model,
+		},
+		providers: cfg.providers,
+	};
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.mkdir(base, { recursive: true }).catch(() => {});
+	} catch {}
+	await Bun.write(path, JSON.stringify(next, null, 2));
+}
+
+export async function writeAuth(
+	provider: ProviderId,
+	info: AuthInfo,
+	scope: Scope = 'global',
+	projectRoot?: string,
+) {
+	await setAuthFile(provider, info, projectRoot, scope);
+}
+
+export async function removeAuth(
+	provider: ProviderId,
+	scope: Scope = 'global',
+	projectRoot?: string,
+) {
+	await removeAuthFile(provider, projectRoot, scope);
+}

package/src/config/src/paths.ts

@@ -0,0 +1,98 @@
+// Utilities for resolving AGI config/data paths consistently
+// Uses XDG base directory spec for global config: ~/.config/agi by default
+
+// Minimal path join to avoid node:path; ensures forward slashes
+function joinPath(...parts: string[]) {
+	return parts
+		.filter(Boolean)
+		.map((p) => p.replace(/\\/g, '/'))
+		.join('/')
+		.replace(/\/+\/+/g, '/');
+}
+
+export function getHomeDir(): string {
+	return (process.env.HOME || process.env.USERPROFILE || '').replace(
+		/\\/g,
+		'/',
+	);
+}
+
+export function getConfigHomeDir(): string {
+	const cfgHome = process.env.XDG_CONFIG_HOME;
+	if (cfgHome?.trim()) return cfgHome.replace(/\\/g, '/');
+	return joinPath(getHomeDir(), '.config');
+}
+
+export function getGlobalConfigDir(): string {
+	return joinPath(getConfigHomeDir(), 'agi');
+}
+
+export function getGlobalConfigPath(): string {
+	return joinPath(getGlobalConfigDir(), 'config.json');
+}
+
+export function getGlobalAuthPath(): string {
+	return joinPath(getGlobalConfigDir(), 'auth.json');
+}
+
+// Secure location for auth secrets (not in config dir or project)
+// - Linux: $XDG_STATE_HOME/agi/auth.json or ~/.local/state/agi/auth.json
+// - macOS: ~/Library/Application Support/agi/auth.json
+// - Windows: %APPDATA%\agi\auth.json
+export function getSecureAuthPath(): string {
+	const platform = process.platform;
+	if (platform === 'darwin') {
+		return joinPath(
+			getHomeDir(),
+			'Library',
+			'Application Support',
+			'agi',
+			'auth.json',
+		);
+	}
+	if (platform === 'win32') {
+		const appData = (process.env.APPDATA || '').replace(/\\/g, '/');
+		const base = appData || joinPath(getHomeDir(), 'AppData', 'Roaming');
+		return joinPath(base, 'agi', 'auth.json');
+	}
+	const stateHome = (process.env.XDG_STATE_HOME || '').replace(/\\/g, '/');
+	const base = stateHome || joinPath(getHomeDir(), '.local', 'state');
+	return joinPath(base, 'agi', 'auth.json');
+}
+
+// Global content under config dir
+export function getGlobalAgentsJsonPath(): string {
+	return joinPath(getGlobalConfigDir(), 'agents.json');
+}
+
+export function getGlobalAgentsDir(): string {
+	return joinPath(getGlobalConfigDir(), 'agents');
+}
+
+export function getGlobalToolsDir(): string {
+	return joinPath(getGlobalConfigDir(), 'tools');
+}
+
+export function getGlobalCommandsDir(): string {
+	return joinPath(getGlobalConfigDir(), 'commands');
+}
+
+export function getLocalDataDir(projectRoot: string): string {
+	return joinPath(projectRoot, '.agi');
+}
+
+export async function ensureDir(dir: string) {
+	try {
+		// Attempt to create a marker file to ensure directory exists
+		await Bun.write(joinPath(dir, '.keep'), '');
+	} catch {
+		const { promises: fs } = await import('node:fs');
+		await fs.mkdir(dir, { recursive: true }).catch(() => {});
+	}
+}
+
+export async function fileExists(p: string) {
+	return await Bun.file(p).exists();
+}
+
+export { joinPath };