DeepWiki

08 - Configuration-&-Deployment

Relevant source files

This document provides a comprehensive guide to configuring and deploying the godeep.wiki system. It covers environment variable configuration, GitHub App setup, Vercel deployment procedures, automation script configuration, and operational monitoring requirements.

For information about the admin panel's runtime token generation functionality, see Admin Panel. For details about the automation pipeline architecture, see Automation System.

The system requires multiple categories of environment variables for different integrations and components. All variables must be configured before deployment.

The following diagram shows how environment variables are consumed by different system components:

Diagram: Environment Variable Dependencies and Consumer Components

Sources: .env.example L1-L15

README.md L73-L91

The following table documents all required environment variables, their purposes, and where to obtain them:

VariablePurposeSourceRequired By
GITHUB_APP_SLUGGitHub App URL identifierGitHub App settings pageOAuth initiation, automation scripts
GITHUB_APP_IDGitHub App numeric identifierGitHub App settings pageToken generation API
GITHUB_CLIENT_IDOAuth client identifierGitHub App OAuth settingsOAuth flow endpoints
GITHUB_CLIENT_SECRETOAuth client secretGitHub App OAuth settings (generate new)Token exchange in callback
GITHUB_PRIVATE_KEYGitHub App private key (PEM format)GitHub App settings (generate new)JWT signing for installation tokens
GITHUB_WEBHOOK_SECRETWebhook signature validation secretGitHub App webhook settingsWebhook endpoints (if implemented)
NEXT_PUBLIC_APP_URLApplication base URLYour domain or Vercel URLRedirect URLs, absolute URL construction
NEXT_PUBLIC_ADMIN_PASSWORDAdmin panel authentication passwordSet manually (simple string)Admin panel authentication
STRIPE_PUBLISHABLE_KEYStripe public keyStripe dashboardFrontend payment button
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEYStripe public key (client-accessible)Stripe dashboardClient-side Stripe.js initialization
STRIPE_SECRET_KEYStripe API secret keyStripe dashboardServer-side Stripe API calls
STRIPE_WEBHOOK_SECRETStripe webhook signing secretStripe webhook configurationWebhook signature verification
STRIPE_MCP_KEYStripe MCP integration keyStripe dashboard (if using MCP)MCP-related features (optional)
NTFY_TOPICntfy.sh topic name for notificationsChoose unique topic nameWebhook notifications, automation script subscription
NEXT_PUBLIC_CF_BEACON_TOKENCloudflare Analytics beacon tokenCloudflare dashboard (optional)Analytics tracking

Sources: .env.example L1-L15

README.md L76-L91

GITHUB_PRIVATE_KEY Format: The private key must be in PEM format with newlines preserved. When adding to Vercel or .env file, replace newlines with \n:

GITHUB_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA...\n-----END RSA PRIVATE KEY-----"

NEXT_PUBLIC_ Prefix: Variables prefixed with NEXT_PUBLIC_ are exposed to the browser. This is why NEXT_PUBLIC_ADMIN_PASSWORD represents a security consideration—the password is client-accessible and should be considered weak protection.

NTFY_TOPIC Naming: Use a unique, hard-to-guess topic name to prevent unauthorized access to notifications. Example: klaudioz-codex-alerts-<random-string>.

Sources: .env.example L1-L15

README.md L73-L91

The GitHub App provides OAuth authentication and repository access capabilities. It must be created and configured before the system can authenticate users or access repositories.

Diagram: GitHub App Configuration Flow and Required Settings

Sources: README.md L102-L149

github-app-description.md L1-L47

Step 1: Navigate to GitHub App Settings

For organization-owned apps:

https://github.com/organizations/YOUR_ORG/settings/apps/new

For personal apps:

https://github.com/settings/apps/new

Step 2: Configure Basic Information

FieldValueNotes
GitHub App namegodeepwiki-github-integration (or your choice)This becomes part of GITHUB_APP_SLUG
DescriptionCopy from github-app-description.mdUse the "Very Short Version" for character limits
Homepage URLYour NEXT_PUBLIC_APP_URLe.g., https://godeep.wiki
Callback URL{NEXT_PUBLIC_APP_URL}/api/auth/github/callbackMust match exactly for OAuth to work

Recommended Description Text:

Allows users to share a repo to generate a deep documentation

⚠️ Please select "Only select repositories" during installation 
for security. Choose only the repo you want to document.

Sources: README.md L110-L126

github-app-description.md L40-L46

Step 3: Configure Permissions

Repository Permissions:

  • Contents: Read-only ✅
  • Metadata: Read-only ✅

Account Permissions:

  • Email addresses: Read-only ✅

These minimal permissions align with the principle of least privilege. The app never writes to repositories.

Step 4: Configure OAuth Settings

  • ✅ Request user authorization (OAuth) during installation: REQUIRED
  • ⬜ Enable Device Flow: Optional

Enabling OAuth during installation ensures users go through the OAuth flow handled by app/api/auth/github/route.ts L1-L50

and app/api/auth/github/callback/route.ts L1-L200

Sources: README.md L128-L145

Step 5: Generate and Store Credentials

After clicking "Create GitHub App", GitHub generates credentials:

  1. Note the App ID: Displayed at the top of the app settings page * Store in GITHUB_APP_ID
  2. Note the Client ID: Found in the "OAuth" section * Store in GITHUB_CLIENT_ID
  3. Generate Client Secret: Click "Generate a new client secret" in OAuth section * Store in GITHUB_CLIENT_SECRET * This can only be viewed once—save it immediately
  4. Generate Private Key: Scroll to "Private keys" section, click "Generate a private key" * Downloads a .pem file * Convert to single-line format for GITHUB_PRIVATE_KEY
  5. Derive App Slug: From the GitHub App URL * URL format: https://github.com/apps/YOUR-APP-SLUG * Store the slug portion in GITHUB_APP_SLUG

Private Key Conversion Example:

# Original .pem file has newlinescat your-app.2024-01-01.private-key.pem# Convert to single-line format for .envcat your-app.2024-01-01.private-key.pem | awk '{printf "%s\\n", $0}' | pbcopy

Sources: README.md L146-L149

.env.example L1-L7

After creation, access your GitHub App settings at:

Organization App:

https://github.com/organizations/{ORG_NAME}/settings/apps/{APP_SLUG}

Personal App:

https://github.com/settings/apps/{APP_SLUG}

Public Installation URL (users visit this to install):

https://github.com/apps/{APP_SLUG}/installations/new

This URL is constructed by app/api/auth/github/route.ts L1-L50

during OAuth initiation.

Sources: README.md L152-L156

Important Security Note:

When users install the GitHub App, they see two options:

  • ⚪ All repositories
  • ⚪ Only select repositories

The system strongly recommends users select "Only select repositories" and choose only the repository they want documented. This recommendation is included in the GitHub App description.

Why This Matters:

  • Limits attack surface if credentials are compromised
  • Follows principle of least privilege
  • User controls the scope, not the app developer
  • The automation scripts in ntfy-godeep-automation.sh L1-L200 will only clone the selected repositories

Implementation Note: The choice between "All repositories" and "Only select repositories" is user-controlled during installation, not app-controlled. The app developer cannot enforce this restriction programmatically—it must be communicated through the app description.

Sources: README.md L141-L145

github-app-description.md L8-L11

The system is designed for deployment on Vercel, which provides hosting for the Next.js application, serverless API routes, and edge functions.

Diagram: Deployed System Architecture on Vercel

Sources: README.md L265-L290

High-level diagrams

The fastest deployment method is using the Vercel Deploy button:

Deploy with Vercel

Deployment Steps:

  1. Click the "Deploy with Vercel" button
  2. Vercel prompts for environment variables
  3. Enter all required variables from the table above
  4. Vercel clones the repository to your account
  5. Vercel builds and deploys the application
  6. Note the deployment URL for NEXT_PUBLIC_APP_URL

Post-Deployment Configuration:

After deployment, you must update the NEXT_PUBLIC_APP_URL variable:

  1. Go to Vercel Project Settings > Environment Variables
  2. Edit NEXT_PUBLIC_APP_URL to match your actual deployment URL
  3. Redeploy the application for changes to take effect

Sources: README.md L267-L271

For more control over the deployment process, use the Vercel CLI:

Step 1: Install Vercel CLI

npm install -g vercel

Step 2: Link Project

# Navigate to project directorycd godeep.wiki# Link to Vercel (creates .vercel directory)vercel link

Step 3: Configure Environment Variables

Add each environment variable individually:

vercel env add GITHUB_APP_SLUG# Vercel prompts: Enter value for GITHUB_APP_SLUG:# Enter your GitHub App slugvercel env add GITHUB_APP_IDvercel env add GITHUB_CLIENT_IDvercel env add GITHUB_CLIENT_SECRETvercel env add GITHUB_PRIVATE_KEYvercel env add GITHUB_WEBHOOK_SECRETvercel env add NEXT_PUBLIC_APP_URLvercel env add NEXT_PUBLIC_ADMIN_PASSWORDvercel env add STRIPE_SECRET_KEYvercel env add STRIPE_PUBLISHABLE_KEYvercel env add NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEYvercel env add STRIPE_WEBHOOK_SECRETvercel env add NTFY_TOPICvercel env add NEXT_PUBLIC_CF_BEACON_TOKEN

For each variable, specify the environment:

  • Production
  • Preview
  • Development

Typically, set variables for all three environments initially, then customize as needed.

Step 4: Deploy to Preview

# Deploy to preview environment (generates preview URL)vercel

Step 5: Deploy to Production

# Deploy to productionvercel --prod

Sources: README.md L273-L290

Accessing Environment Variables:

  1. Navigate to Vercel Dashboard
  2. Select your project
  3. Go to Settings > Environment Variables

Variable Scopes:

  • Production: Used for production deployments (vercel --prod)
  • Preview: Used for git branch deployments
  • Development: Used for local development with vercel dev

Updating Variables:

When you update an environment variable in Vercel:

  1. The change takes effect for new deployments only
  2. Existing deployments continue using old values
  3. You must redeploy to apply changes

Triggering Redeploy:

# Option 1: Manual redeployvercel --prod# Option 2: Push to connected git branch (triggers automatic deployment)git push origin main

Vercel CLI Environment Variable Commands:

# List all environment variablesvercel env ls# Remove an environment variablevercel env rm VARIABLE_NAME# Pull environment variables to local .envvercel env pull .env.local

Sources: README.md L282-L289

The automation scripts run on external machines (not on Vercel) and listen to ntfy.sh notifications to trigger repository cloning. Two script variants are provided: local and remote.

Diagram: Automation Script Deployment and Communication Flow

Sources: ntfy-godeep-automation.sh L1-L200

ntfy-godeep-automation-remote.sh L1-L200

High-level diagrams

Featurentfy-godeep-automation.shntfy-godeep-automation-remote.sh
Target EnvironmentmacOS local machineLinux server / VPS
Notification Systemosascript (macOS notifications)None (silent operation)
Typical Use CaseDevelopment testingProduction automation
Dependenciesbash, curl, jq, gh CLI, osascriptbash, curl, jq, gh CLI
AdvantagesVisual feedback, easy debuggingRuns headless, always available
DisadvantagesRequires machine to be runningNo visual feedback

Sources: ntfy-godeep-automation.sh L1-L50

ntfy-godeep-automation-remote.sh L1-L50

Prerequisites:

All scripts require:

  • bash (4.0+)
  • curl (for HTTP requests)
  • jq (JSON parsing)
  • gh (GitHub CLI, authenticated)
  • git (for cloning repositories)

Step 1: Install Dependencies

macOS (using Homebrew):

brew install jq ghgh auth login

Linux:

# Debian/Ubuntuapt-get install jq gh git# RedHat/CentOSyum install jq gh git# Authenticate GitHub CLIgh auth login

Step 2: Configure Script Variables

Edit the script file and set environment variables:

# Open the scriptvim ntfy-godeep-automation.sh  # or ntfy-godeep-automation-remote.sh# Configure these variables at the top of the script:NTFY_TOPIC="your-topic-name"           # Must match Vercel NTFY_TOPICADMIN_API_URL="https://godeep.wiki/api/admin/generate-token"ADMIN_PASSWORD="your-admin-password"    # Must match NEXT_PUBLIC_ADMIN_PASSWORDCLONE_BASE_DIR="$HOME/godeep-clones"   # Where to clone repos

Step 3: Make Script Executable

chmod +x ntfy-godeep-automation.sh# orchmod +x ntfy-godeep-automation-remote.sh

Step 4: Test Script Manually

Run the script in foreground to verify configuration:

./ntfy-godeep-automation.sh# Script subscribes to ntfy topic and waits for messages# Ctrl+C to stop

Step 5: Set Up Background Execution

macOS (using launchd):

Create ~/Library/LaunchAgents/com.godeep.automation.plist:

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict>    <key>Label</key>    <string>com.godeep.automation</string>    <key>ProgramArguments</key>    <array>        <string>/path/to/ntfy-godeep-automation.sh</string>    </array>    <key>RunAtLoad</key>    <true/>    <key>KeepAlive</key>    <true/>    <key>StandardErrorPath</key>    <string>/tmp/godeep-automation.err</string>    <key>StandardOutPath</key>    <string>/tmp/godeep-automation.out</string></dict></plist>

Load the service:

launchctl load ~/Library/LaunchAgents/com.godeep.automation.plistlaunchctl start com.godeep.automation

Linux (using systemd):

Create /etc/systemd/system/godeep-automation.service:

[Unit]Description=GoDeep Wiki Automation ScriptAfter=network.target[Service]Type=simpleUser=youruserExecStart=/path/to/ntfy-godeep-automation-remote.shRestart=alwaysRestartSec=10[Install]WantedBy=multi-user.target

Enable and start the service:

sudo systemctl daemon-reloadsudo systemctl enable godeep-automation.servicesudo systemctl start godeep-automation.service

Sources: ntfy-godeep-automation.sh L1-L100

ntfy-godeep-automation-remote.sh L1-L100

Notification Listening:

Scripts subscribe to ntfy.sh using long-polling:

curl -s "https://ntfy.sh/$NTFY_TOPIC/json"

This creates a persistent connection that receives notifications as they arrive.

Processing Flow:

  1. Receive Notification from ntfy.sh
  2. Extract installation_id from notification JSON
  3. Call Token API at /api/admin/generate-token with installation_id and ADMIN_PASSWORD
  4. Receive Response containing: * Short-lived installation access token (1-hour expiry) * List of repositories accessible via this installation
  5. Clone Repository using token: git clone https://x-access-token:${TOKEN}@github.com/${REPO_FULL_NAME}.git
  6. Re-initialize Git: * Remove original .git directory * git init new repository * git add . and git commit all files
  7. Create Private Repository in klaudioz account: sql gh repo create klaudioz/${CUSTOMER_EMAIL}-${REPO_NAME} --private --source . --push
  8. Cleanup local clone to free disk space
  9. Notify completion (macOS script shows notification)

Error Handling:

Scripts include error handling for:

  • Network failures (retries)
  • Invalid JSON responses
  • Missing installation_id
  • Token generation failures
  • Repository cloning failures
  • GitHub CLI errors

Sources: ntfy-godeep-automation.sh L50-L200

ntfy-godeep-automation-remote.sh L50-L200

Vercel Monitoring:

  • Monitor deployment status in Vercel dashboard
  • Check function execution logs in Vercel > Logs
  • Set up Vercel monitoring alerts for failed deployments
  • Track function invocation counts and duration

ntfy.sh Monitoring:

  • Verify notification delivery using ntfy.sh web interface: yaml https://ntfy.sh/YOUR_TOPIC
  • Ensure ntfy topic is not publicly discoverable (use random string in name)
  • Monitor for missed notifications (check timestamp gaps)

GitHub App Monitoring:

  • Review GitHub App installations at app settings page
  • Check for revoked installations
  • Monitor API rate limits (5,000 requests/hour per installation)
  • Verify webhook delivery (if webhooks configured)

Stripe Monitoring:

  • Monitor payment events in Stripe dashboard
  • Verify webhook delivery in Stripe > Developers > Webhooks
  • Check for failed payment events
  • Review checkout session completion rates

Automation Script Monitoring:

For local scripts:

# Check if process is runningps aux | grep ntfy-godeep-automation# View logs (if using launchd)tail -f /tmp/godeep-automation.outtail -f /tmp/godeep-automation.err

For remote scripts:

# Check systemd statussudo systemctl status godeep-automation# View logssudo journalctl -u godeep-automation -f

Sources: Based on system architecture and deployment patterns

Since the system has no database, correlation between payments and repository access requires manual log inspection:

Step 1: Customer Makes Payment

  • Stripe generates session_id
  • Webhook sends notification to ntfy.sh with last 12 characters as "Match ID"

Step 2: Customer Connects GitHub

  • OAuth callback receives installation_id
  • Logs to Vercel console: session_id + installation_id + user details

Step 3: Owner Correlates Payment to Installation

  1. Access Stripe dashboard → Payments
  2. Find payment by customer email or date
  3. Copy full session_id
  4. Access Vercel dashboard → Logs
  5. Search for session_id in logs
  6. Find the log entry that includes both session_id and installation_id
  7. Note the installation_id

Step 4: Owner Uses installation_id

  • Visit admin panel at /admin
  • Enter installation_id
  • Generate installation access token
  • Access customer repositories manually

Verification Command:

To verify correlation in logs:

vercel logs --output raw | grep "session_id.*installation_id"

Sources: High-level Diagram 5 (Data Correlation and Tracking)

Issue: OAuth Redirect 404 Error

Symptom: GitHub redirects to 404 page after OAuth approval

Cause: Callback URL mismatch between GitHub App configuration and actual deployment URL

Solution:

  1. Verify NEXT_PUBLIC_APP_URL matches deployment URL exactly (no trailing slash)
  2. Check GitHub App callback URL: {NEXT_PUBLIC_APP_URL}/api/auth/github/callback
  3. Ensure URLs match exactly (including protocol: https://)
  4. Redeploy after updating environment variables

Issue: Stripe Webhook Signature Verification Failed

Symptom: Webhook endpoint returns 400 error, logs show "Invalid signature"

Cause: STRIPE_WEBHOOK_SECRET mismatch

Solution:

  1. Go to Stripe Dashboard > Developers > Webhooks
  2. Click on your webhook endpoint
  3. Reveal the signing secret
  4. Update STRIPE_WEBHOOK_SECRET in Vercel
  5. Redeploy application

Issue: Automation Script Not Receiving Notifications

Symptom: Script runs but doesn't process any notifications

Cause: NTFY_TOPIC mismatch or network connectivity

Solution:

  1. Verify script's NTFY_TOPIC matches Vercel environment variable
  2. Test ntfy connectivity: curl https://ntfy.sh/YOUR_TOPIC/json
  3. Send test notification: curl -d "Test message" https://ntfy.sh/YOUR_TOPIC
  4. Check firewall rules (ensure outbound HTTPS allowed)

Issue: Admin Panel Authentication Failed

Symptom: Correct password rejected by admin panel

Cause: Browser cached old password or environment variable not updated

Solution:

  1. Clear browser localStorage: localStorage.removeItem("isAdminAuthenticated");
  2. Verify NEXT_PUBLIC_ADMIN_PASSWORD in Vercel matches password being entered
  3. Redeploy after updating environment variable (NEXT_PUBLIC_ requires rebuild)

Issue: Installation Token Generation Returns 401

Symptom: /api/admin/generate-token returns authentication error

Cause: GITHUB_PRIVATE_KEY formatting issue or expired/invalid

Solution:

  1. Regenerate GitHub App private key
  2. Verify PEM format conversion (check for \n line breaks)
  3. Ensure no extra spaces or characters in environment variable
  4. Test JWT generation locally before deploying

Sources: README.md L314-L367

Operational experience patterns

Environment Variable Security:

  • Never commit .env file to version control (already in .gitignore)
  • Rotate GITHUB_CLIENT_SECRET and STRIPE_SECRET_KEY periodically
  • Use strong, random values for NEXT_PUBLIC_ADMIN_PASSWORD
  • Limit access to Vercel project settings (team permissions)

ntfy.sh Topic Security:

  • Use long, random, unguessable topic names
  • Consider running private ntfy.sh server for production
  • Do not log full ntfy notification payloads (may contain sensitive data)

GitHub App Security:

  • Regularly review installed instances of your GitHub App
  • Revoke unused or suspicious installations
  • Monitor GitHub App audit logs
  • Keep private key secure (never share or commit)

Webhook Security:

  • Always verify webhook signatures (app/api/webhooks/stripe/route.ts L1-L100 implements this)
  • Use HTTPS-only endpoints (enforced by Vercel)
  • Implement rate limiting for webhook endpoints (currently not implemented—consider adding)

Admin Panel Security:

  • The current NEXT_PUBLIC_ADMIN_PASSWORD approach exposes password to client
  • For production, consider implementing server-side session authentication
  • Add rate limiting to prevent brute force attacks (currently not implemented)
  • Consider IP allowlisting for /admin and /api/admin/* routes

Sources: High-level Diagram 6 (Security Model and Threat Mitigation), README.md L394-L406

Critical Data to Backup:

  1. Environment Variables * Export from Vercel: Settings > Environment Variables > Export * Store in secure password manager
  2. GitHub App Credentials * Private key (cannot be recovered if lost—requires regeneration) * Client secret (can be regenerated) * Installation IDs for active customers
  3. Stripe Configuration * Webhook endpoints configuration * Product/price IDs * API keys (can be regenerated)
  4. Deployment Logs * Vercel logs expire after 7 days on free plan * Export critical logs containing session_id + installation_id correlations * Store in external logging service for long-term retention

Recovery Procedures:

Scenario: Vercel Project Deleted

  1. Redeploy from GitHub repository
  2. Restore environment variables from backup
  3. Update GitHub App callback URL to new Vercel URL
  4. Test OAuth flow and webhook delivery

Scenario: GitHub App Deleted

  1. Create new GitHub App following configuration steps above
  2. Update environment variables with new credentials
  3. Existing installations are lost—users must reinstall
  4. Notify customers of required reinstallation

Scenario: Lost GITHUB_PRIVATE_KEY

  1. Generate new private key in GitHub App settings
  2. Update GITHUB_PRIVATE_KEY in Vercel
  3. Existing installation tokens become invalid
  4. Automation scripts must regenerate tokens for future installations

Sources: Operational best practices and system architecture

Use this checklist to verify complete configuration before going live:

  • GitHub App created with correct name
  • Repository permissions set (Contents: Read, Metadata: Read)
  • Account permissions set (Email: Read)
  • OAuth enabled during installation
  • Callback URL configured: {APP_URL}/api/auth/github/callback
  • Homepage URL set to your domain
  • Description includes "Only select repositories" recommendation
  • Private key generated and downloaded
  • Client secret generated
  • App ID noted
  • GITHUB_APP_SLUG matches GitHub App URL slug
  • GITHUB_APP_ID set to numeric app ID
  • GITHUB_CLIENT_ID from GitHub App OAuth section
  • GITHUB_CLIENT_SECRET from GitHub App OAuth section
  • GITHUB_PRIVATE_KEY in proper PEM format with \n
  • GITHUB_WEBHOOK_SECRET generated (if using webhooks)
  • NEXT_PUBLIC_APP_URL matches deployment URL exactly
  • NEXT_PUBLIC_ADMIN_PASSWORD set to secure value
  • STRIPE_SECRET_KEY from Stripe dashboard
  • STRIPE_PUBLISHABLE_KEY from Stripe dashboard
  • NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY same as above
  • STRIPE_WEBHOOK_SECRET from Stripe webhook configuration
  • NTFY_TOPIC set to unique, random topic name
  • NEXT_PUBLIC_CF_BEACON_TOKEN from Cloudflare (optional)
  • Application deployed to Vercel
  • All environment variables configured in Vercel project settings
  • Production deployment successful
  • Homepage loads correctly
  • SSL certificate active (HTTPS working)
  • Custom domain configured (if applicable)
  • Stripe account configured
  • Product created: "DeepWiki Analysis" at $10
  • Webhook endpoint configured: {APP_URL}/api/webhooks/stripe
  • Webhook listening for checkout.session.completed event
  • Webhook secret noted and configured in environment variables
  • Test payment completed successfully
  • Script dependencies installed (jq, gh, curl, git)
  • GitHub CLI authenticated (gh auth login)
  • Script variables configured (NTFY_TOPIC, ADMIN_PASSWORD, API_URL)
  • Script made executable (chmod +x)
  • Script tested in foreground
  • Background service configured (launchd or systemd)
  • Service started and running
  • Clone directory created and writable
  • Test notification processed successfully
  • Complete user flow tested: payment → GitHub connection → thank you page
  • OAuth flow successful (callback receives code and installation_id)
  • Stripe webhook notification received by ntfy.sh
  • Automation script receives ntfy notification
  • Token generation API returns valid token
  • Repository clone successful
  • Private repository created in klaudioz account
  • Admin panel accessible with correct password
  • Manual token generation works via admin panel

Sources: All sections above

This completes the configuration and deployment documentation. For runtime operations and manual documentation generation workflows, see Admin Panel and Automation System.

Refresh this wiki

Last indexed: 23 November 2025 (922b35)

On this page

Ask Devin about godeep.wiki-jb

Syntax error in text

mermaid version 11.4.1

08 - Configuration-&-Deployment | DeepWiki | godeep.wiki