chore: cleaned up types

packages/cli/src/commands/init.ts

···
 				defaultValue: "7",
 				placeholder: "7",
 				validate: (value) => {
-					const num = parseInt(value, 10);
+					if (!value) {
+						return "Please enter a number";
+					}
+					const num = Number.parseInt(value, 10);
 					if (Number.isNaN(num) || num < 1) {
 						return "Please enter a positive number";
 					}

packages/cli/src/commands/login.ts

···
 import { resolveHandleToDid } from "../lib/atproto";
 import {
 	getCallbackPort,
-	getCallbackUrl,
 	getOAuthClient,
 	getOAuthScope,
 } from "../lib/oauth-client";

packages/cli/src/commands/publish.ts

···
 		let agent: Awaited<ReturnType<typeof createAgent>> | undefined;
 		try {
 			agent = await createAgent(credentials);
-			s.stop(`Logged in as ${agent.session?.handle}`);
+			s.stop(`Logged in as ${agent.did}`);
 		} catch (error) {
 			s.stop("Failed to login");
 			log.error(`Failed to login: ${error}`);

packages/cli/src/commands/sync.ts

···
 		let agent: Awaited<ReturnType<typeof createAgent>> | undefined;
 		try {
 			agent = await createAgent(credentials);
-			s.stop(`Logged in as ${agent.session?.handle}`);
+			s.stop(`Logged in as ${agent.did}`);
 		} catch (error) {
 			s.stop("Failed to login");
 			log.error(`Failed to login: ${error}`);

packages/cli/src/lib/atproto.ts

···
 } from "./types";
 import { isAppPasswordCredentials, isOAuthCredentials } from "./types";
 
+/**
+ * Type guard to check if a record value is a DocumentRecord
+ */
+function isDocumentRecord(value: unknown): value is DocumentRecord {
+	if (!value || typeof value !== "object") return false;
+	const v = value as Record<string, unknown>;
+	return (
+		v.$type === "site.standard.document" &&
+		typeof v.title === "string" &&
+		typeof v.site === "string" &&
+		typeof v.path === "string" &&
+		typeof v.textContent === "string" &&
+		typeof v.publishedAt === "string"
+	);
+}
+
 async function fileExists(filePath: string): Promise<boolean> {
 	try {
 		await fs.access(filePath);
···
 	showInDiscover?: boolean;
 }
 
-export async function createAgent(credentials: Credentials): Promise<AtpAgent> {
+export async function createAgent(credentials: Credentials): Promise<Agent> {
 	if (isOAuthCredentials(credentials)) {
 		// OAuth flow - restore session from stored tokens
 		const client = await getOAuthClient();
 		try {
 			const oauthSession = await client.restore(credentials.did);
 			// Wrap the OAuth session in an Agent which provides the atproto API
-			const agent = new Agent(oauthSession) as unknown as AtpAgent;
-
-			// The Agent class doesn't have session.did like AtpAgent does
-			// We need to set up a compatible session object for the rest of our code
-			agent.session = {
-				did: oauthSession.did,
-				handle: credentials.handle,
-				accessJwt: "",
-				refreshJwt: "",
-				active: true,
-			};
-
-			return agent;
+			return new Agent(oauthSession);
 		} catch (error) {
 			if (error instanceof Error) {
 				// Check for common OAuth errors
···
 }
 
 export async function uploadImage(
-	agent: AtpAgent,
+	agent: Agent,
 	imagePath: string,
 ): Promise<BlobObject | undefined> {
 	if (!(await fileExists(imagePath))) {
···
 }
 
 export async function createDocument(
-	agent: AtpAgent,
+	agent: Agent,
 	post: BlogPost,
 	config: PublisherConfig,
 	coverImage?: BlobObject,
···
 	}
 
 	const response = await agent.com.atproto.repo.createRecord({
-		repo: agent.session!.did,
+		repo: agent.did!,
 		collection: "site.standard.document",
 		record,
 	});
···
 }
 
 export async function updateDocument(
-	agent: AtpAgent,
+	agent: Agent,
 	post: BlogPost,
 	atUri: string,
 	config: PublisherConfig,
···
 	}
 
 	await agent.com.atproto.repo.putRecord({
-		repo: agent.session!.did,
+		repo: agent.did!,
 		collection: collection!,
 		rkey: rkey!,
 		record,
···
 }
 
 export async function listDocuments(
-	agent: AtpAgent,
+	agent: Agent,
 	publicationUri?: string,
 ): Promise<ListDocumentsResult[]> {
 	const documents: ListDocumentsResult[] = [];
···
 
 	do {
 		const response = await agent.com.atproto.repo.listRecords({
-			repo: agent.session!.did,
+			repo: agent.did!,
 			collection: "site.standard.document",
 			limit: 100,
 			cursor,
 		});
 
 		for (const record of response.data.records) {
-			const value = record.value as unknown as DocumentRecord;
+			if (!isDocumentRecord(record.value)) {
+				continue;
+			}
 
 			// If publicationUri is specified, only include documents from that publication
-			if (publicationUri && value.site !== publicationUri) {
+			if (publicationUri && record.value.site !== publicationUri) {
 				continue;
 			}
 
 			documents.push({
 				uri: record.uri,
 				cid: record.cid,
-				value,
+				value: record.value,
 			});
 		}
 
···
 }
 
 export async function createPublication(
-	agent: AtpAgent,
+	agent: Agent,
 	options: CreatePublicationOptions,
 ): Promise<string> {
 	let icon: BlobObject | undefined;
···
 	}
 
 	const response = await agent.com.atproto.repo.createRecord({
-		repo: agent.session!.did,
+		repo: agent.did!,
 		collection: "site.standard.publication",
 		record,
 	});
···
  * Create a Bluesky post with external link embed
  */
 export async function createBlueskyPost(
-	agent: AtpAgent,
+	agent: Agent,
 	options: CreateBlueskyPostOptions,
 ): Promise<StrongRef> {
 	const { title, description, canonicalUrl, coverImage, publishedAt } = options;
···
 	};
 
 	const response = await agent.com.atproto.repo.createRecord({
-		repo: agent.session!.did,
+		repo: agent.did!,
 		collection: "app.bsky.feed.post",
 		record,
 	});
···
  * Add bskyPostRef to an existing document record
  */
 export async function addBskyPostRefToDocument(
-	agent: AtpAgent,
+	agent: Agent,
 	documentAtUri: string,
 	bskyPostRef: StrongRef,
 ): Promise<void> {

packages/cli/src/lib/credentials.ts

···
 		}
 	}
 
-	// Otherwise, check all OAuth sessions to find a matching handle
-	// (This is a fallback - handle matching isn't perfect without storing handles)
-	const sessions = await listOAuthSessions();
-	for (const did of sessions) {
-		// Could enhance this by storing handle with session, but for now
-		// just return null if profile isn't a DID
-	}
-
+	// Otherwise, we would need to check all OAuth sessions to find a matching handle,
+	// but handle matching isn't perfect without storing handles alongside sessions.
+	// For now, just return null if profile isn't a DID.
 	return null;
 }
 

packages/cli/src/lib/oauth-client.ts

···
 // This prevents the "No lock mechanism provided" warning
 const locks = new Map<string, Promise<void>>();
 
-async function requestLock(key: string, fn: () => Promise<void>): Promise<void> {
+async function requestLock<T>(
+	key: string,
+	fn: () => T | PromiseLike<T>,
+): Promise<T> {
 	// Wait for any existing lock on this key
 	while (locks.has(key)) {
 		await locks.get(key);
···
 	locks.set(key, lockPromise);
 
 	try {
-		await fn();
+		return await fn();
 	} finally {
 		locks.delete(key);
 		resolve!();