@rubytech/create-maxy 0.4.5 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Install Maxy — your personal AI assistant",
   "bin": {
     "create-maxy": "./dist/index.js"

package/payload/maxy/app/api/onboarding/claude-auth/route.ts

@@ -1,8 +1,53 @@
 import { NextResponse } from 'next/server'
-import { spawn, execFileSync, type ChildProcess } from 'node:child_process'
+import { execFileSync } from 'node:child_process'
+import { loginAnthropic, type OAuthCredentials } from '@mariozechner/pi-ai'
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { homedir } from 'node:os'
+
+// --- Active OAuth session (same pattern as v1 gateway/server-methods/auth.ts) ---
+
+type OAuthSession = {
+  authUrl: string | null
+  codeResolver: ((code: string) => void) | null
+  codePromise: Promise<string> | null
+  completed: boolean
+  error: string | null
+  credentials: OAuthCredentials | null
+}
+
+let activeSession: OAuthSession | null = null
+
+function resetSession(): void {
+  activeSession = null
+}
+
+// --- Claude CLI credentials ---
+
+const CLAUDE_CREDS_PATH = resolve(homedir(), '.claude/.credentials.json')
+
+function writeClaudeCredentials(creds: OAuthCredentials): void {
+  const claudeDir = resolve(homedir(), '.claude')
+  mkdirSync(claudeDir, { recursive: true })
+
+  let data: Record<string, unknown> = {}
+  if (existsSync(CLAUDE_CREDS_PATH)) {
+    try {
+      data = JSON.parse(readFileSync(CLAUDE_CREDS_PATH, 'utf-8'))
+    } catch { /* start fresh */ }
+  }
 
-// Keep the login process alive between requests so we can feed it the code
-let loginProcess: ChildProcess | null = null
+  data.claudeAiOauth = {
+    ...(typeof data.claudeAiOauth === 'object' && data.claudeAiOauth ? data.claudeAiOauth : {}),
+    accessToken: creds.access,
+    refreshToken: creds.refresh,
+    expiresAt: creds.expires,
+  }
+
+  writeFileSync(CLAUDE_CREDS_PATH, JSON.stringify(data, null, 2), { mode: 0o600 })
+}
+
+// --- Endpoints ---
 
 /**
  * GET /api/onboarding/claude-auth
@@ -26,112 +71,118 @@ export async function GET() {
 
 /**
  * POST /api/onboarding/claude-auth
- * Body: {} — starts the login flow, returns the auth URL (with code=true for headless)
- * Body: { code: "..." } — feeds the auth code to the waiting login process
+ * Three actions:
+ * - {} — start OAuth flow, returns authUrl
+ * - { code: "..." } — submit the auth code
+ * - { action: "wait" } — poll for completion
  */
 export async function POST(req: Request) {
-  let body: { code?: string } = {}
+  let body: { code?: string; action?: string } = {}
   try {
     body = await req.json()
   } catch { /* empty body = start flow */ }
 
-  // --- Submit code to running process ---
-  if (body.code && loginProcess) {
-    loginProcess.stdin?.write(body.code + '\n')
-
-    // Wait for process to handle the code
-    await new Promise<void>((resolve) => {
-      const timeout = setTimeout(() => resolve(), 8000)
-      loginProcess?.on('exit', () => {
-        clearTimeout(timeout)
-        resolve()
-      })
-    })
-
-    loginProcess = null
+  // --- Submit code ---
+  if (body.code) {
+    if (!activeSession?.codeResolver) {
+      return NextResponse.json(
+        { error: 'No active OAuth session. Click "Sign in with Claude" to start again.' },
+        { status: 400 },
+      )
+    }
 
-    // Check result
-    try {
-      const output = execFileSync('claude', ['auth', 'status', '--json'], {
-        encoding: 'utf-8',
-        timeout: 5000,
-      })
-      const status = JSON.parse(output)
-      if (status.loggedIn) {
-        return NextResponse.json({ authenticated: true, email: status.email })
-      }
-    } catch { /* */ }
+    activeSession.codeResolver(body.code.trim())
 
-    return NextResponse.json({
-      authenticated: false,
-      error: 'Authentication failed. Check the code and try again.',
-    })
+    return NextResponse.json({ message: 'Code received — verifying...' })
   }
 
-  // --- Start new login flow ---
-  if (loginProcess) {
-    loginProcess.kill()
-    loginProcess = null
-  }
+  // --- Poll for completion ---
+  if (body.action === 'wait') {
+    if (!activeSession) {
+      return NextResponse.json({ completed: false, error: 'No active session.' })
+    }
 
-  return new Promise<Response>((resolve) => {
-    // Use `script` to provide a PTY so claude auth login gets its interactive prompt.
-    // On Linux (Pi): script -qc "command" /dev/null
-    // On macOS: script -q /dev/null command args
-    const isLinux = process.platform === 'linux'
-    const child = isLinux
-      ? spawn('script', ['-qc', 'claude auth login', '/dev/null'], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: { ...process.env, BROWSER: 'echo', TERM: 'dumb' },
-        })
-      : spawn('script', ['-q', '/dev/null', 'claude', 'auth', 'login'], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: { ...process.env, BROWSER: 'echo', TERM: 'dumb' },
-        })
-
-    loginProcess = child
-
-    let output = ''
-    let resolved = false
-
-    function tryResolve() {
-      if (resolved) return
-      const match = output.match(/(https:\/\/claude\.ai\/oauth\/authorize[^\s]+)/)
-      if (match) {
-        resolved = true
-        resolve(NextResponse.json({ authUrl: match[1] }))
+    // Poll for up to 5 seconds
+    const start = Date.now()
+    while (Date.now() - start < 5000) {
+      if (activeSession.completed) {
+        if (activeSession.error) {
+          const error = activeSession.error
+          resetSession()
+          return NextResponse.json({ completed: true, authenticated: false, error })
+        }
+
+        resetSession()
+        return NextResponse.json({ completed: true, authenticated: true })
       }
+      await new Promise(r => setTimeout(r, 500))
     }
 
-    child.stdout?.on('data', (chunk: Buffer) => {
-      output += chunk.toString()
-      tryResolve()
-    })
+    return NextResponse.json({ completed: false })
+  }
 
-    child.stderr?.on('data', (chunk: Buffer) => {
-      output += chunk.toString()
-      tryResolve()
-    })
+  // --- Start OAuth flow ---
+  resetSession()
+
+  activeSession = {
+    authUrl: null,
+    codeResolver: null,
+    codePromise: null,
+    completed: false,
+    error: null,
+    credentials: null,
+  }
+
+  // Set up code promise (resolved when user submits code via POST { code })
+  activeSession.codePromise = new Promise<string>((resolve) => {
+    activeSession!.codeResolver = resolve
+  })
 
-    child.on('exit', () => {
-      if (!resolved) {
-        resolved = true
-        loginProcess = null
-        resolve(NextResponse.json(
-          { error: 'Login process exited unexpectedly.' },
-          { status: 500 },
-        ))
+  // Start OAuth flow in background (same as v1)
+  const oauthPromise = loginAnthropic(
+    // onAuthUrl — called when we have the URL
+    (url: string) => {
+      if (activeSession) {
+        activeSession.authUrl = url
+      }
+    },
+    // onPromptCode — called when the library needs the code
+    async (): Promise<string> => {
+      if (!activeSession?.codePromise) {
+        throw new Error('OAuth session expired')
+      }
+      return activeSession.codePromise
+    },
+  )
+
+  // Handle completion in background
+  oauthPromise
+    .then((credentials) => {
+      if (activeSession) {
+        activeSession.credentials = credentials
+        activeSession.completed = true
+        writeClaudeCredentials(credentials)
       }
     })
-
-    setTimeout(() => {
-      if (!resolved) {
-        resolved = true
-        resolve(NextResponse.json(
-          { error: 'Could not start auth flow. Is Claude Code installed?' },
-          { status: 500 },
-        ))
+    .catch((err) => {
+      if (activeSession) {
+        activeSession.error = err instanceof Error ? err.message : String(err)
+        activeSession.completed = true
       }
-    }, 15000)
-  })
+    })
+
+  // Wait for the auth URL to appear
+  await new Promise(r => setTimeout(r, 500))
+  if (!activeSession?.authUrl) {
+    await new Promise(r => setTimeout(r, 1500))
+  }
+
+  if (!activeSession?.authUrl) {
+    return NextResponse.json(
+      { error: 'Failed to start OAuth flow.' },
+      { status: 500 },
+    )
+  }
+
+  return NextResponse.json({ authUrl: activeSession.authUrl })
 }

package/payload/maxy/app/page.tsx

@@ -290,17 +290,35 @@ export default function AdminPage() {
       setAuthLoading(true)
       setPinError('')
       try {
-        const res = await fetch('/api/onboarding/claude-auth', {
+        // Submit the code
+        await fetch('/api/onboarding/claude-auth', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ code: authCode.trim() }),
         })
-        const data = await res.json()
-        if (data.authenticated) {
-          setAppState('enter-pin')
-        } else {
-          setPinError(data.error || 'Authentication failed. Check the code and try again.')
+
+        // Poll for completion
+        for (let i = 0; i < 12; i++) {
+          const waitRes = await fetch('/api/onboarding/claude-auth', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action: 'wait' }),
+          })
+          const waitData = await waitRes.json()
+
+          if (waitData.completed) {
+            if (waitData.authenticated) {
+              setAppState('enter-pin')
+              return
+            } else {
+              setPinError(waitData.error || 'Authentication failed. Check the code and try again.')
+              setAuthLoading(false)
+              return
+            }
+          }
         }
+
+        setPinError('Timed out waiting for verification. Try again.')
       } catch {
         setPinError('Could not verify code.')
       }