572 lines
15 KiB
TypeScript
572 lines
15 KiB
TypeScript
import { BrowserOAuthClient } from '@atproto/oauth-client-browser';
|
|
import { Agent } from '@atproto/api';
|
|
|
|
interface AtprotoSession {
|
|
did: string;
|
|
handle: string;
|
|
accessJwt: string;
|
|
refreshJwt: string;
|
|
email?: string;
|
|
emailConfirmed?: boolean;
|
|
}
|
|
|
|
class AtprotoOAuthService {
|
|
private oauthClient: BrowserOAuthClient | null = null;
|
|
private oauthClientSyuIs: BrowserOAuthClient | null = null;
|
|
private agent: Agent | null = null;
|
|
private initializePromise: Promise<void> | null = null;
|
|
|
|
constructor() {
|
|
// Don't initialize immediately, wait for first use
|
|
}
|
|
|
|
private async initialize(): Promise<void> {
|
|
// Prevent multiple initializations
|
|
if (this.initializePromise) {
|
|
return this.initializePromise;
|
|
}
|
|
|
|
this.initializePromise = this._doInitialize();
|
|
return this.initializePromise;
|
|
}
|
|
|
|
private async _doInitialize(): Promise<void> {
|
|
try {
|
|
// Generate client ID based on current origin
|
|
const clientId = this.getClientId();
|
|
|
|
// Initialize both OAuth clients
|
|
this.oauthClient = await BrowserOAuthClient.load({
|
|
clientId: clientId,
|
|
handleResolver: 'https://bsky.social',
|
|
plcDirectoryUrl: 'https://plc.directory',
|
|
});
|
|
|
|
this.oauthClientSyuIs = await BrowserOAuthClient.load({
|
|
clientId: clientId,
|
|
handleResolver: 'https://syu.is',
|
|
plcDirectoryUrl: 'https://plc.syu.is',
|
|
});
|
|
|
|
// Try to restore existing session from either client
|
|
let result = await this.oauthClient.init();
|
|
if (!result?.session) {
|
|
result = await this.oauthClientSyuIs.init();
|
|
}
|
|
if (result?.session) {
|
|
|
|
// Create Agent instance with proper configuration
|
|
|
|
|
|
// Delete the old agent initialization code - we'll create it properly below
|
|
|
|
// Set the session after creating the agent
|
|
// The session object from BrowserOAuthClient appears to be a special object
|
|
|
|
|
|
|
|
|
|
// Try to iterate over the session object
|
|
if (result.session) {
|
|
|
|
for (const key in result.session) {
|
|
|
|
}
|
|
|
|
// Check if session has methods
|
|
const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(result.session));
|
|
|
|
}
|
|
|
|
// BrowserOAuthClient might return a Session object that needs to be used with the agent
|
|
// Let's try to use the session object directly with the agent
|
|
if (result.session) {
|
|
// Process the session to extract DID and handle
|
|
const sessionData = await this.processSession(result.session);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
} catch (error) {
|
|
|
|
this.initializePromise = null; // Reset on error to allow retry
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private async processSession(session: any): Promise<{ did: string; handle: string }> {
|
|
const did = session.sub || session.did;
|
|
let handle = session.handle || 'unknown';
|
|
|
|
// Create Agent directly with session (per official docs)
|
|
try {
|
|
this.agent = new Agent(session);
|
|
} catch (err) {
|
|
// Fallback to dpopFetch method
|
|
this.agent = new Agent({
|
|
service: session.server?.serviceEndpoint || 'https://bsky.social',
|
|
fetch: session.dpopFetch
|
|
});
|
|
}
|
|
|
|
// Store basic session info
|
|
(this as any)._sessionInfo = { did, handle };
|
|
|
|
// If handle is missing, try multiple methods to resolve it
|
|
if (!handle || handle === 'unknown') {
|
|
|
|
|
|
// Method 1: Try using the agent to get profile
|
|
try {
|
|
await new Promise(resolve => setTimeout(resolve, 300));
|
|
const profile = await this.agent.getProfile({ actor: did });
|
|
if (profile.data.handle) {
|
|
handle = profile.data.handle;
|
|
(this as any)._sessionInfo.handle = handle;
|
|
|
|
return { did, handle };
|
|
}
|
|
} catch (err) {
|
|
|
|
}
|
|
|
|
// Method 2: Try using describeRepo
|
|
try {
|
|
const repoDesc = await this.agent.com.atproto.repo.describeRepo({
|
|
repo: did
|
|
});
|
|
if (repoDesc.data.handle) {
|
|
handle = repoDesc.data.handle;
|
|
(this as any)._sessionInfo.handle = handle;
|
|
|
|
return { did, handle };
|
|
}
|
|
} catch (err) {
|
|
|
|
}
|
|
|
|
// Method 3: Fallback for admin DID
|
|
const adminDid = import.meta.env.VITE_ADMIN_DID;
|
|
if (did === adminDid) {
|
|
const appHost = import.meta.env.VITE_APP_HOST || 'https://syui.ai';
|
|
handle = new URL(appHost).hostname;
|
|
(this as any)._sessionInfo.handle = handle;
|
|
|
|
}
|
|
}
|
|
|
|
return { did, handle };
|
|
}
|
|
|
|
private getClientId(): string {
|
|
// Use environment variable if available
|
|
const envClientId = import.meta.env.VITE_OAUTH_CLIENT_ID;
|
|
if (envClientId) {
|
|
|
|
return envClientId;
|
|
}
|
|
|
|
const origin = window.location.origin;
|
|
|
|
// For localhost development, use undefined for loopback client
|
|
// The BrowserOAuthClient will handle this automatically
|
|
if (origin.includes('localhost') || origin.includes('127.0.0.1')) {
|
|
|
|
return undefined as any; // Loopback client
|
|
}
|
|
|
|
// Default: use origin-based client metadata
|
|
return `${origin}/client-metadata.json`;
|
|
}
|
|
|
|
|
|
async initiateOAuthFlow(handle?: string): Promise<void> {
|
|
try {
|
|
if (!this.oauthClient || !this.oauthClientSyuIs) {
|
|
await this.initialize();
|
|
}
|
|
|
|
if (!this.oauthClient || !this.oauthClientSyuIs) {
|
|
throw new Error('Failed to initialize OAuth clients');
|
|
}
|
|
|
|
// If handle is not provided, prompt user
|
|
if (!handle) {
|
|
handle = prompt('ハンドルを入力してください (例: user.bsky.social または user.syu.is):');
|
|
if (!handle) {
|
|
throw new Error('Handle is required for authentication');
|
|
}
|
|
}
|
|
|
|
// Determine which OAuth client to use
|
|
const allowedHandlesStr = import.meta.env.VITE_ATPROTO_HANDLE_LIST || '[]';
|
|
let allowedHandles: string[] = [];
|
|
try {
|
|
allowedHandles = JSON.parse(allowedHandlesStr);
|
|
} catch {
|
|
allowedHandles = [];
|
|
}
|
|
|
|
const usesSyuIs = handle.endsWith('.syu.is') || allowedHandles.includes(handle);
|
|
const oauthClient = usesSyuIs ? this.oauthClientSyuIs : this.oauthClient;
|
|
|
|
// Start OAuth authorization flow
|
|
const authUrl = await oauthClient.authorize(handle, {
|
|
scope: 'atproto transition:generic',
|
|
});
|
|
|
|
// Redirect to authorization server
|
|
window.location.href = authUrl.toString();
|
|
|
|
} catch (error) {
|
|
throw new Error(`OAuth認証の開始に失敗しました: ${error}`);
|
|
}
|
|
}
|
|
|
|
async handleOAuthCallback(): Promise<{ did: string; handle: string } | null> {
|
|
try {
|
|
|
|
|
|
|
|
|
|
|
|
// BrowserOAuthClient should automatically handle the callback
|
|
// We just need to initialize it and it will process the current URL
|
|
if (!this.oauthClient) {
|
|
|
|
await this.initialize();
|
|
}
|
|
|
|
if (!this.oauthClient) {
|
|
throw new Error('Failed to initialize OAuth client');
|
|
}
|
|
|
|
|
|
|
|
// Call init() again to process the callback URL
|
|
const result = await this.oauthClient.init();
|
|
|
|
|
|
if (result?.session) {
|
|
// Process the session
|
|
return this.processSession(result.session);
|
|
}
|
|
|
|
// If no session yet, wait a bit and try again
|
|
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
|
|
// Try to check session again
|
|
const sessionCheck = await this.checkSession();
|
|
if (sessionCheck) {
|
|
|
|
return sessionCheck;
|
|
}
|
|
|
|
|
|
return null;
|
|
|
|
} catch (error) {
|
|
|
|
throw new Error(`OAuth認証の完了に失敗しました: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
async checkSession(): Promise<{ did: string; handle: string } | null> {
|
|
try {
|
|
if (!this.oauthClient) {
|
|
await this.initialize();
|
|
}
|
|
|
|
if (!this.oauthClient) {
|
|
return null;
|
|
}
|
|
|
|
const result = await this.oauthClient.init();
|
|
|
|
if (result?.session) {
|
|
// Use the common session processing method
|
|
return this.processSession(result.session);
|
|
}
|
|
|
|
return null;
|
|
} catch (error) {
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
getAgent(): Agent | null {
|
|
return this.agent;
|
|
}
|
|
|
|
getSession(): AtprotoSession | null {
|
|
|
|
|
|
// First check if we have an agent with session
|
|
if (this.agent?.session) {
|
|
const session = {
|
|
did: this.agent.session.did,
|
|
handle: this.agent.session.handle || 'unknown',
|
|
accessJwt: this.agent.session.accessJwt || '',
|
|
refreshJwt: this.agent.session.refreshJwt || '',
|
|
};
|
|
|
|
return session;
|
|
}
|
|
|
|
// If no agent.session but we have stored session info, return that
|
|
if ((this as any)._sessionInfo) {
|
|
const session = {
|
|
did: (this as any)._sessionInfo.did,
|
|
handle: (this as any)._sessionInfo.handle,
|
|
accessJwt: 'dpop-protected', // Indicate that tokens are handled by dpopFetch
|
|
refreshJwt: 'dpop-protected',
|
|
};
|
|
|
|
return session;
|
|
}
|
|
|
|
|
|
return null;
|
|
}
|
|
|
|
isAuthenticated(): boolean {
|
|
return !!this.agent || !!(this as any)._sessionInfo;
|
|
}
|
|
|
|
getUser(): { did: string; handle: string } | null {
|
|
const session = this.getSession();
|
|
if (!session) return null;
|
|
|
|
return {
|
|
did: session.did,
|
|
handle: session.handle
|
|
};
|
|
}
|
|
|
|
async logout(): Promise<void> {
|
|
try {
|
|
// Clear Agent
|
|
this.agent = null;
|
|
|
|
// Clear BrowserOAuthClient session
|
|
if (this.oauthClient) {
|
|
try {
|
|
// BrowserOAuthClient may have a revoke or signOut method
|
|
if (typeof (this.oauthClient as any).signOut === 'function') {
|
|
await (this.oauthClient as any).signOut();
|
|
} else if (typeof (this.oauthClient as any).revoke === 'function') {
|
|
await (this.oauthClient as any).revoke();
|
|
}
|
|
} catch (oauthError) {
|
|
// Ignore logout errors
|
|
}
|
|
|
|
// Reset the OAuth client to force re-initialization
|
|
this.oauthClient = null;
|
|
this.initializePromise = null;
|
|
}
|
|
|
|
// Clear any stored session data
|
|
localStorage.removeItem('atproto_session');
|
|
sessionStorage.clear();
|
|
|
|
// Clear all OAuth-related storage
|
|
for (let i = 0; i < localStorage.length; i++) {
|
|
const key = localStorage.key(i);
|
|
if (key && (key.includes('oauth') || key.includes('atproto') || key.includes('session'))) {
|
|
localStorage.removeItem(key);
|
|
}
|
|
}
|
|
|
|
// Clear internal session info
|
|
(this as any)._sessionInfo = null;
|
|
|
|
|
|
|
|
// Force page reload to ensure clean state
|
|
setTimeout(() => {
|
|
window.location.reload();
|
|
}, 100);
|
|
|
|
} catch (error) {
|
|
|
|
}
|
|
}
|
|
|
|
// カードデータをatproto collectionに保存
|
|
async saveCardToBox(userCards: any[]): Promise<void> {
|
|
// Ensure we have a valid session
|
|
const sessionInfo = await this.checkSession();
|
|
if (!sessionInfo) {
|
|
throw new Error('認証が必要です。ログインしてください。');
|
|
}
|
|
|
|
const did = sessionInfo.did;
|
|
|
|
try {
|
|
|
|
|
|
|
|
// Ensure we have a fresh agent
|
|
if (!this.agent) {
|
|
throw new Error('Agentが初期化されていません。');
|
|
}
|
|
|
|
const collection = 'ai.card.box';
|
|
const rkey = 'self';
|
|
const createdAt = new Date().toISOString();
|
|
|
|
// カードボックスのレコード
|
|
const record = {
|
|
$type: 'ai.card.box',
|
|
cards: userCards.map(card => ({
|
|
id: card.id,
|
|
cp: card.cp,
|
|
status: card.status,
|
|
skill: card.skill,
|
|
owner_did: card.owner_did,
|
|
obtained_at: card.obtained_at,
|
|
is_unique: card.is_unique,
|
|
unique_id: card.unique_id
|
|
|
|
})),
|
|
total_cards: userCards.length,
|
|
updated_at: createdAt,
|
|
createdAt: createdAt
|
|
};
|
|
|
|
|
|
// Use Agent's com.atproto.repo.putRecord method
|
|
const response = await this.agent.com.atproto.repo.putRecord({
|
|
repo: did,
|
|
collection: collection,
|
|
rkey: rkey,
|
|
record: record
|
|
});
|
|
|
|
|
|
} catch (error) {
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// ai.card.boxからカード一覧を取得
|
|
async getCardsFromBox(): Promise<any> {
|
|
// Ensure we have a valid session
|
|
const sessionInfo = await this.checkSession();
|
|
if (!sessionInfo) {
|
|
throw new Error('認証が必要です。ログインしてください。');
|
|
}
|
|
|
|
const did = sessionInfo.did;
|
|
|
|
try {
|
|
|
|
|
|
|
|
// Ensure we have a fresh agent
|
|
if (!this.agent) {
|
|
throw new Error('Agentが初期化されていません。');
|
|
}
|
|
|
|
const response = await this.agent.com.atproto.repo.getRecord({
|
|
repo: did,
|
|
collection: 'ai.card.box',
|
|
rkey: 'self'
|
|
});
|
|
|
|
|
|
|
|
// Convert to expected format
|
|
const result = {
|
|
records: [{
|
|
uri: `at://${did}/ai.card.box/self`,
|
|
cid: response.data.cid,
|
|
value: response.data.value
|
|
}]
|
|
};
|
|
|
|
return result;
|
|
} catch (error) {
|
|
|
|
|
|
// If record doesn't exist, return empty
|
|
if (error.toString().includes('RecordNotFound')) {
|
|
return { records: [] };
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// ai.card.boxのコレクションを削除
|
|
async deleteCardBox(): Promise<void> {
|
|
// Ensure we have a valid session
|
|
const sessionInfo = await this.checkSession();
|
|
if (!sessionInfo) {
|
|
throw new Error('認証が必要です。ログインしてください。');
|
|
}
|
|
|
|
const did = sessionInfo.did;
|
|
|
|
try {
|
|
|
|
|
|
|
|
// Ensure we have a fresh agent
|
|
if (!this.agent) {
|
|
throw new Error('Agentが初期化されていません。');
|
|
}
|
|
|
|
const response = await this.agent.com.atproto.repo.deleteRecord({
|
|
repo: did,
|
|
collection: 'ai.card.box',
|
|
rkey: 'self'
|
|
});
|
|
|
|
|
|
} catch (error) {
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// 手動でトークンを設定（開発・デバッグ用）
|
|
setManualTokens(accessJwt: string, refreshJwt: string): void {
|
|
|
|
|
|
|
|
// For backward compatibility, store in localStorage
|
|
const adminDid = import.meta.env.VITE_ADMIN_DID || 'did:plc:unknown';
|
|
const appHost = import.meta.env.VITE_APP_HOST || 'https://example.com';
|
|
const session: AtprotoSession = {
|
|
did: adminDid,
|
|
handle: new URL(appHost).hostname,
|
|
accessJwt: accessJwt,
|
|
refreshJwt: refreshJwt
|
|
};
|
|
|
|
localStorage.setItem('atproto_session', JSON.stringify(session));
|
|
|
|
}
|
|
|
|
// 後方互換性のための従来関数
|
|
saveSessionToStorage(session: AtprotoSession): void {
|
|
|
|
localStorage.setItem('atproto_session', JSON.stringify(session));
|
|
}
|
|
|
|
async backupUserCards(userCards: any[]): Promise<void> {
|
|
return this.saveCardToBox(userCards);
|
|
}
|
|
}
|
|
|
|
export const atprotoOAuthService = new AtprotoOAuthService();
|
|
export type { AtprotoSession };
|