Developer Spoke Integration Guide

const express = require('express');
const crypto = require('crypto');
const app = express();

const BROKER_URL = 'https://noctisid.com';
const CLIENT_ID = process.env.NOCTISID_CLIENT_ID;
const CLIENT_SECRET = process.env.NOCTISID_CLIENT_SECRET;

// 1. Initiate Login Redirect
app.get('/auth/login/:provider', (req, res) => {
  const provider = req.params.provider; // e.g. 'google' or 'apple'
  const state = crypto.randomBytes(16).toString('hex');
  req.session.oauth_state = state;

  const authUrl = `${BROKER_URL}/oauth/authorize?client_id=${CLIENT_ID}&provider=${provider}&redirect_uri=https://yourdomain.com/auth/callback&state=${state}`;
  res.redirect(authUrl);
});

// 2. Consume 60s Single-Use Ticket
app.get('/auth/callback', async (req, res) => {
  const { ticket, state } = req.query;

  if (state !== req.session.oauth_state) {
    return res.status(403).send('State nonce mismatch.');
  }

  try {
    const exchangeRes = await fetch(`${BROKER_URL}/oauth/token`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        client_id: CLIENT_ID,
        client_secret: CLIENT_SECRET,
        ticket: ticket,
        grant_type: 'ticket_exchange'
      })
    });

    if (!exchangeRes.ok) {
      return res.status(401).send('Ticket redemption rejected or expired.');
    }

    const { user, access_token } = await exchangeRes.json();

    // 3. Establish Local Session
    req.session.user = user;
    res.redirect('/portal/dashboard');
  } catch (err) {
    console.error('Handshake failed:', err);
    res.status(500).send('Internal auth error.');
  }
});

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import RedirectResponse
import httpx
import os

app = FastAPI()
BROKER_URL = "https://noctisid.com"
CLIENT_ID = os.getenv("NOCTISID_CLIENT_ID")
CLIENT_SECRET = os.getenv("NOCTISID_CLIENT_SECRET")

@app.get("/auth/callback")
async def auth_callback(ticket: str, state: str, request: Request):
    # Verify state against session cookie
    if state != request.session.get("oauth_state"):
        raise HTTPException(status_code=403, detail="Invalid state token")

    # Atomic Ticket Redemption
    async with httpx.AsyncClient() as client:
        res = await client.post(
            f"{BROKER_URL}/oauth/token",
            json={
                "client_id": CLIENT_ID,
                "client_secret": CLIENT_SECRET,
                "ticket": ticket,
                "grant_type": "ticket_exchange"
            },
            timeout=10.0
        )
        
        if res.status_code != 200:
            raise HTTPException(status_code=401, detail="Ticket expired or burned")
            
        data = res.json()
        user_claims = data["user"]
        
    # Store authenticated user in session
    request.session["user"] = user_claims
    return RedirectResponse(url="/dashboard", status_code=303)

<!-- 1. Include NoctisID SDK -->
<script src="https://noctisid.com/assets/js/sdk.js" 
        data-client-id="cid_live_example_9918ab"></script>

<!-- 2. Trigger Social Handshakes with Custom Buttons -->
<button class="btn btn-google" onclick="NoctisID.login('google')">
  Sign in with Google
</button>

<button class="btn btn-apple" onclick="NoctisID.login('apple')">
  Sign in with Apple
</button>

<!-- Optional: Listen for Authentication Events -->
<script>
  window.addEventListener('noctisid:success', (e) => {
    console.log('User authenticated!', e.detail.user);
    window.location.reload();
  });
</script>

// 1. Swift (iOS) — In-App Authentication with PKCE
import AuthenticationServices

class AuthManager: NSObject {
    func startLogin(provider: String) {
        let codeVerifier = generateRandomString(64)
        let codeChallenge = sha256Base64Url(codeVerifier)
        let callbackScheme = "myapp" // Registered Custom URL Scheme

        let authURL = URL(string: "https://noctisid.com/oauth/authorize?" +
            "client_id=cid_live_mobile_app77&" +
            "provider=\(provider)&" +
            "redirect_uri=myapp://oauth/callback&" +
            "code_challenge=\(codeChallenge)&" +
            "code_challenge_method=S256")!

        let session = ASWebAuthenticationSession(url: authURL, callbackURLScheme: callbackScheme) { callbackURL, error in
            guard let callbackURL = callbackURL, error == nil else { return }
            
            // Extract the 60s single-use ticket
            let components = URLComponents(url: callbackURL, resolvingAgainstBaseURL: false)
            if let ticket = components?.queryItems?.first(where: { $0.name == "ticket" })?.value {
                self.exchangeTicketWithPKCE(ticket: ticket, verifier: codeVerifier)
            }
        }
        session.presentationContextProvider = self
        session.start()
    }
}