Password Pusher

https://docs.pwpush.com
Admin
Securely share sensitive information with automatic expiration & deletion. Track who, what, and when...
Tokens:108,984
Snippets:1,429
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Docker Compose Example for Dual-Container Setup

Source: https://docs.pwpush.com/docs/public-gateway

An example docker-compose.yml file demonstrating a dual-container setup for pwpush, including internal application, public gateway, and PostgreSQL database.

```yaml
services:
  # Internal full application (for your team)
  pwpush-internal:
    image: docker.io/pglombardo/pwpush:stable
    restart: unless-stopped
    environment:
      DATABASE_URL: postgres://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db
      PWPUSH_MASTER_KEY: 'your-encryption-key-here'
      PWP__OVERRIDE_BASE_URL: 'https://gateway.example.com'
      # ... other configuration ...
    depends_on:
      - postgres

  # Public gateway (for external users)
  pwpush-gateway:
    image: docker.io/pglombardo/pwpush-public-gateway:stable
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      DATABASE_URL: postgres://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db
      PWPUSH_MASTER_KEY: 'your-encryption-key-here'
      PWP__OVERRIDE_BASE_URL: 'https://gateway.example.com'
      TLS_DOMAIN: 'gateway.example.com'
      # ... same configuration as internal container ...

  # Shared database
  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: pwpush_user
      POSTGRES_PASSWORD: pwpush_passwd
      POSTGRES_DB: pwpush_db
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

```

--------------------------------

### PostgreSQL Local Server Example

Source: https://docs.pwpush.com/docs/database_url

Example DATABASE_URL for connecting to a local PostgreSQL server.

```plaintext
postgres://myuser:mypassword@localhost:5432/pwpush_db
```

--------------------------------

### Complete Docker Compose Example for Ephemeral Database

Source: https://docs.pwpush.com/docs/persist-ephemeral

A complete Docker Compose example demonstrating an ephemeral database setup. Ensure no volumes are mounted to the database location for data to be discarded on container stop.

```yaml
services:
  pwpush:
    image: docker.io/pglombardo/pwpush:stable
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      PWPUSH_MASTER_KEY: 'your-encryption-key-here'
      TLS_DOMAIN: 'pwpush.example.com'
      # No volumes = ephemeral database

```

--------------------------------

### PostgreSQL SSL Connection Example

Source: https://docs.pwpush.com/docs/database_url

Example DATABASE_URL for connecting to PostgreSQL with SSL enabled.

```plaintext
postgres://myuser:mypassword@db.example.com:5432/pwpush_db?sslmode=require
```

--------------------------------

### Start Console using Bundler

Source: https://docs.pwpush.com/docs/application-console

Alternatively, for non-Docker installations, you can start the Rails console using `bundle exec rails console`. This ensures that the console runs within the context of your application's defined gems.

```bash
bundle exec rails console

```

--------------------------------

### Example Output of SECRET_KEY_BASE Generation

Source: https://docs.pwpush.com/docs/application-encryption

This is an example of the output generated when creating a new SECRET_KEY_BASE.

```text
f7af32f6f51fff9df4e0ae9dd127a6588ab07d0988bd805ba5e650cb5399z30cc225aec2848c9c763549c31260203a751601e7ef28c2b7aa353ee533644c0d05

```

--------------------------------

### Complete Docker Compose Example with Custom Settings Overlay

Source: https://docs.pwpush.com/docs/overlay-file-docker

This is a full `docker-compose.yml` example demonstrating how to overlay a custom `settings.yml` file and configure persistent storage and environment variables for Password Pusher.

```yaml
services:
  pwpush:
    image: docker.io/pglombardo/pwpush:stable
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      # Overlay custom settings.yml
      - type: bind
        source: ./config/settings.yml
        target: /opt/PasswordPusher/config/settings.yml
        read_only: true
      # Persistent storage
      - pwpush-storage:/opt/PasswordPusher/storage
    environment:
      PWPUSH_MASTER_KEY: 'your-encryption-key-here'
      TLS_DOMAIN: 'pwpush.example.com'

volumes:
  pwpush-storage:

```

--------------------------------

### PostgreSQL Remote Server Example

Source: https://docs.pwpush.com/docs/database_url

Example DATABASE_URL for connecting to a remote PostgreSQL server.

```plaintext
postgres://myuser:mypassword@db.example.com:5432/pwpush_db
```

--------------------------------

### PostgreSQL Docker Compose Example

Source: https://docs.pwpush.com/docs/database_url

Example DATABASE_URL for connecting to a PostgreSQL service within Docker Compose.

```plaintext
postgres://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db
```

--------------------------------

### Database URL Examples for Universal Container

Source: https://docs.pwpush.com/docs/how-to-universal

Examples of DATABASE_URL configurations for different database backends supported by the universal Password Pusher container. These examples show the required prefix and connection details for PostgreSQL, MySQL, MariaDB, and SQLite3.

```shell
# PostgreSQL
DATABASE_URL=postgresql://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db

```

```shell
# MySQL (note the prefix 'mysql2')
DATABASE_URL=mysql2://pwpush_user:pwpush_passwd@mysql:3306/pwpush_db

```

```shell
# MariaDB (note the prefix 'mysql2')
DATABASE_URL=mysql2://pwpush_user:pwpush_passwd@mariadb:3306/pwpush_db

```

```shell
# SQLite3 (ephemeral/lost on container restart)
DATABASE_URL=sqlite3:db/db.sqlite3

```

--------------------------------

### Start Console in Non-Docker Installations

Source: https://docs.pwpush.com/docs/application-console

For installations not using Docker, navigate to your application's root directory and execute this command to start the Rails console. This assumes you have the application code and dependencies set up on the server.

```bash
# Navigate to your application directory
cd /path/to/PasswordPusher

# Start the console
bin/pwpush console

```

--------------------------------

### Install QEMU for Cross-Platform Builds

Source: https://docs.pwpush.com/docs/building-docker

Install QEMU using a privileged Docker container to enable cross-platform builds. This is often a prerequisite for successful multi-platform image creation.

```bash
docker run --privileged --rm tonistiigi/binfmt --install all

```

--------------------------------

### Example: Multi-Regional Deployment Configuration

Source: https://docs.pwpush.com/docs/languages

Example configuration for a deployment serving multiple regions, including English, Spanish, Brazilian Portuguese, and French.

```yaml
# settings.yml
default_locale: en
enabled_language_codes:
  - en    # English
  - es    # Español
  - pt-BR # Português (Brazil)
  - fr    # Français
```

--------------------------------

### Install Password Pusher Pro Helm Chart (Starter Edition)

Source: https://docs.pwpush.com/docs/pro-self-hosted-kubernetes

Installs the Password Pusher Pro Helm chart for the Starter edition, specifying license details and the image pull secret.

```bash
helm install my-push pwpush-pro/pwpush-pro \
  --set license.key=YOUR_LICENSE_KEY \
  --set license.region=YOUR_REGION \
  --set imagePullSecrets[0].name=regcred

```

--------------------------------

### Push Creation Response Example

Source: https://docs.pwpush.com/docs/api-v1

This is an example of the JSON response received after successfully creating a push, including details like URL token and custom domain URLs.

```json
{
   "account_id":1,
   "expire_after_duration":8,
   "expire_after_views":5,
   "url_token":"wbjm73kig9kv4gbe_q",
   ..snipped..,
   "html_url":"https://pwp.mycompany.com/p/wbjm73kig9kv4gbe_q/r",
   "note":"For New Employee ID 12345"
}
```

--------------------------------

### Ephemeral Docker Compose Setup

Source: https://docs.pwpush.com/docs/persist-ephemeral

This example `docker-compose.yml` configures an ephemeral setup for PasswordPusher, suitable for temporary use cases like security conferences. Note the absence of a `volumes` section, ensuring data is lost upon container removal.

```yaml
services:
  pwpush:
    image: docker.io/pglombardo/pwpush:stable
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      # Required: Encryption key
      PWPUSH_MASTER_KEY: 'your-generated-encryption-key-here'

      # Optional: Automatic TLS
      TLS_DOMAIN: 'pwpush.conference.example.com'

      # Optional: Explicit ephemeral database location
      DATABASE_URL: "sqlite3:db/db.sqlite3"

      # Optional: Customize expiration defaults for temporary use
      PWP__PW__EXPIRE_AFTER_DAYS_DEFAULT: "1"
      PWP__PW__EXPIRE_AFTER_VIEWS_DEFAULT: "1"

    # NO volumes section = ephemeral database
    # All data will be lost when container stops or is removed

```

--------------------------------

### Install and Run swaks for SMTP Diagnostics

Source: https://docs.pwpush.com/docs/troubleshooting-email

Install the 'swaks' tool within the container using apt-get and then use it for further SMTP diagnostics.

```bash
# Install swaks
apt-get update && apt-get install -y swaks

```

--------------------------------

### Set Theme from Source

Source: https://docs.pwpush.com/docs/rebranding

Set the PWP__THEME environment variable in your shell and then start the Password Pusher server when running from source.

```bash
export PWP__THEME=quartz
bin/pwpush server

```

--------------------------------

### Create and Set Custom Theme

Source: https://docs.pwpush.com/docs/rebranding

Example of setting a custom theme by defining the PWP__THEME environment variable to your custom theme's filename.

```bash
PWP__THEME=mynewtheme

```

--------------------------------

### SQLite3 Absolute Path Example

Source: https://docs.pwpush.com/docs/database_url

Example of an absolute path for the SQLite3 database URL, recommended for Docker deployments.

```plaintext
sqlite3:///opt/PasswordPusher/db/production.sqlite3
```

--------------------------------

### Example Custom Domain Configuration

Source: https://docs.pwpush.com/docs/hosted-rebranding

This is an example of how to configure a custom domain for your Password Pusher pushes. Ensure you enter only the domain name without the protocol or path.

```text
pwp.yourdomain.com
```

--------------------------------

### SQLite3 Relative Path Example

Source: https://docs.pwpush.com/docs/database_url

Example of a relative path for the SQLite3 database URL.

```plaintext
sqlite3:db/db.sqlite3
```

--------------------------------

### Gmail SMTP Configuration Example

Source: https://docs.pwpush.com/docs/troubleshooting-email

Example configuration for sending emails via Gmail using SMTP. Requires an application-specific password and enables STARTTLS.

```yaml
mail:
  raise_delivery_errors: true
  smtp_address: smtp.gmail.com
  smtp_port: 587
  smtp_authentication: plain
  smtp_user_name: <your-gmail-email>
  smtp_password: <application-specific-password>
  smtp_enable_starttls_auto: true
  smtp_open_timeout: 10
  smtp_read_timeout: 10

```

--------------------------------

### Example: URL Parameter Override for Language

Source: https://docs.pwpush.com/docs/languages

Demonstrates how to share a push with a specific language using a URL parameter.

```html
https://pwpush.example.com/p/abc123?locale=ja
```

--------------------------------

### Install pgloader using Docker

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Pulls the latest pgloader Docker image. This is an alternative installation method, useful for isolated environments.

```bash
docker pull dimitri/pgloader:latest

```

--------------------------------

### Usage Examples

Source: https://docs.pwpush.com/docs/json-api

Demonstrates how to use the various PWPush API functions in a TypeScript environment. These examples cover anonymous pushes, authenticated pushes with files, URL pushes, QR code pushes, and retrieving lists of pushes.

```typescript
// Create an anonymous push
const push = await createPush('my secret password');

// Create an authenticated push with files
const fileInput = document.querySelector<HTMLInputElement>('input[type="file"]');
if (fileInput?.files) {
  const push = await createAuthenticatedPush({
    payload: 'secure content',
    note: 'For employee onboarding',
    files: Array.from(fileInput.files),
    email: 'your-email@example.com',
    apiToken: 'your-api-token'
  });
}

// Create a URL push
const urlPush = await createURLPush({
  url: 'https://example.com'
});

// Create a QR code push
const qrPush = await createQRPush({
  content: 'QR Code content here'
});

// Get active pushes
const activePushes = await getActivePushes({
  email: 'your-email@example.com',
  apiToken: 'your-api-token'
});

```

--------------------------------

### Docker Compose: PostgreSQL Setup

Source: https://docs.pwpush.com/docs/database_url

Set up a PostgreSQL database and configure Password Pusher to connect to it using the DATABASE_URL environment variable.

```yaml
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: pwpush_user
      POSTGRES_PASSWORD: pwpush_passwd
      POSTGRES_DB: pwpush_db
    volumes:
      - postgres-data:/var/lib/postgresql/data

  pwpush:
    image: docker.io/pglombardo/pwpush:stable
    depends_on:
      - postgres
    environment:
      DATABASE_URL: postgres://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db

volumes:
  postgres-data:

```

--------------------------------

### Example DNS CNAME Record Configuration

Source: https://docs.pwpush.com/docs/hosted-rebranding

This example demonstrates how to configure a CNAME DNS record for a subdomain. CNAME records are universally supported for subdomains and cannot be used at the root domain.

```text
CNAME push.example.com domains-us.pwpush.com
```

--------------------------------

### Example Password Pusher Docker Environment File

Source: https://docs.pwpush.com/docs/docker-env-file

This is an example of a `.env` file used to configure Password Pusher with various settings for mail, file storage, and general behavior.

```env
# Web sign-in: omit PWP__DISABLE_LOGINS or set to false for dashboard/login UI
PWP__MAIL__RAISE_DELIVERY_ERRORS=true
PWP__MAIL__SMTP_ADDRESS=smtp.example.com
PWP__MAIL__SMTP_PORT=587
PWP__MAIL__SMTP_USER_NAME=myuser
PWP__MAIL__SMTP_PASSWORD=mypassword
PWP__MAIL__SMTP_AUTHENTICATION=plain
PWP__MAIL__SMTP_STARTTLS=true
PWP__MAIL__SMTP_OPEN_TIMEOUT=10
PWP__MAIL__SMTP_READ_TIMEOUT=10
PWP__HOST_DOMAIN=example.com
PWP__HOST_PROTOCOL=https
PWP__MAIL__MAILER_SENDER="Sender Name" <email@address.111>
PWP__ENABLE_FILE_PUSHES=true
PWP__FILES__STORAGE=local
PWP__FILES__S3__ENDPOINT=s3.amazonaws.com
PWP__FILES__S3__ACCESS_KEY_ID=BKIBIOSFODNN7EXAMPLE
PWP__FILES__S3__SECRET_ACCESS_KEY=wJalsXUtnaEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
PWP__FILES__S3__REGION=us-west-2
PWP__FILES__S3__BUCKET=my-bucket
PWP__FILES__EXPIRE_AFTER_DAYS_DEFAULT=2
PWP__FILES__EXPIRE_AFTER_DAYS_MAX=7
PWP__FILES__EXPIRE_AFTER_VIEWS_DEFAULT=5
PWP__FILES__EXPIRE_AFTER_VIEWS_MAX=10
PWP__FILES__RETRIEVAL_STEP_DEFAULT=true
PWP__ENABLE_URL_PUSHES=true

```

--------------------------------

### List Active Pushes

Source: https://docs.pwpush.com/docs/json-api

This example shows how to retrieve a list of all active pushes associated with your account. Authentication is required.

```cpp
auto response = cpr::Get(
    cpr::Url{"https://pwpush.com/p/active.json"},
    cpr::Header{
        {"X-User-Email", "your-email@example.com"},
        {"X-User-Token", "MyAPIToken"}
    }
);
auto activePushes = json::parse(response.text);


```

--------------------------------

### Create Push Example

Source: https://docs.pwpush.com/docs/api-v2

This example demonstrates how to create a new password push using API v2. It includes the necessary endpoint, HTTP method, headers, and a sample JSON payload.

```APIDOC
## POST /api/v2/pushes

### Description
Creates a new password push with specified payload, expiration duration, and view limits.

### Method
POST

### Endpoint
https://eu.pwpush.com/api/v2/pushes

### Parameters
#### Request Body
- **push** (object) - Required - The push object containing details.
  - **payload** (string) - Required - The secret content to be pushed.
  - **expire_after_duration** (integer) - Optional - Duration in hours after which the push will expire.
  - **expire_after_views** (integer) - Optional - Number of views after which the push will expire.

### Request Example
```json
{
  "push": {
    "payload": "MySecretPassword123",
    "expire_after_duration": 6,
    "expire_after_views": 3
  }
}
```

### Response
#### Success Response (200)
- **push** (object) - Details of the created push, including its unique URL and expiration information.

#### Response Example
```json
{
  "push": {
    "url": "https://eu.pwpush.com/p/abcdef123456",
    "payload": null,
    "password": null,
    "expire_after_duration": 6,
    "expire_after_views": 3,
    "created_at": "2023-10-27T10:00:00Z",
    "updated_at": "2023-10-27T10:00:00Z",
    "deleted_at": null,
    "expires_at": "2023-10-27T16:00:00Z",
    "view_count": 0,
    "max_views": 3,
    "id": "abcdef123456",
    "token": "abcdef123456",
    "short_url": "https://eu.pwpush.com/p/abcdef123456",
    "api_url": "https://eu.pwpush.com/api/v2/pushes/abcdef123456"
  }
}
```
```

--------------------------------

### Start PostgreSQL Docker Container

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Start the PostgreSQL Docker container using the specified compose file. This command assumes you have saved the configuration in 'docker-compose-postgres.yml'.

```bash
docker compose -f docker-compose-postgres.yml up -d
```

--------------------------------

### Install pgloader on Ubuntu/Debian

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Installs the pgloader tool using the apt package manager. This is the recommended method for Ubuntu and Debian-based systems.

```bash
sudo apt-get update
sudo apt-get install pgloader

```

--------------------------------

### Start Solid Queue Worker on Render

Source: https://docs.pwpush.com/docs/installation

This command is used to start the Solid Queue worker service on Render. It's an optional step if you need a separate worker dyno.

```bash
bundle exec rake solid_queue:start
```

--------------------------------

### Install Enterprise with Bundled PostgreSQL

Source: https://docs.pwpush.com/docs/pro-self-hosted-kubernetes

Installs the pwpush-pro Enterprise edition using the bundled PostgreSQL subchart. Ensure you have a Kubernetes secret named 'regcred' for image pulling and replace placeholders for license key and region.

```bash
helm install my-push pwpush-pro/pwpush-pro \
  -f values-enterprise.yaml \
  --set license.key=YOUR_LICENSE_KEY \
  --set license.region=YOUR_REGION \
  --set imagePullSecrets[0].name=regcred \
  --set postgresql.auth.existingSecret=my-push-pwpush-pro
```

--------------------------------

### Example: French-Speaking Organization Configuration

Source: https://docs.pwpush.com/docs/languages

Example configuration for an organization primarily serving French-speaking users, setting default locale and enabled languages.

```yaml
# settings.yml
default_locale: fr
enabled_language_codes:
  - fr    # Français
  - en    # English (as fallback)
```

--------------------------------

### Install pgloader on RHEL/CentOS/Fedora

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Installs the pgloader tool using the dnf package manager. This is suitable for RHEL, CentOS, and Fedora systems.

```bash
sudo dnf install pgloader

```

--------------------------------

### Install pgloader on macOS with Homebrew

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Installs the pgloader tool using the Homebrew package manager. This is the standard method for macOS users.

```bash
brew install pgloader

```

--------------------------------

### Start New Container with Docker Run (Stable/Latest)

Source: https://docs.pwpush.com/docs/upgrading

Start a new Password Pusher container using `docker run` with the `stable` tag. Ensure to map ports, volumes, and set necessary environment variables.

```bash
# Start a new container with the same configuration
docker run -d \
  --name pwpush \
  -p "80:80" -p "443:443" \
  -v pwpush-storage:/opt/PasswordPusher/storage \
  --env PWPUSH_MASTER_KEY='your-key' \
  pglombardo/pwpush:stable
```

--------------------------------

### Example DNS ALIAS Record Configuration

Source: https://docs.pwpush.com/docs/hosted-rebranding

This example shows how to configure an ALIAS DNS record for a root domain. This record type is best for root domains but may not be supported by all DNS providers.

```text
ALIAS example.com domains-us.pwpush.com
```

--------------------------------

### Password Pusher Pro Self-Hosted Install Command

Source: https://docs.pwpush.com/docs/pro-self-hosted-how-it-works

This is the personalized install command received via email after purchasing a Self-Hosted Pro license. Treat this command as a secret, as it authenticates to the private registry and deploys your application.

```bash
curl -fsSL "https://license-server/install.sh?license_key=YOUR-LICENSE-KEY" | sh
```

--------------------------------

### Run Personalized Install Command

Source: https://docs.pwpush.com/docs/pro-self-hosted-azure

Execute the personalized install command obtained from your provisioning email on the Azure VM. This command pulls image credentials and generates deployment files, including the .env file with encryption keys.

```bash
curl -fsSL "https://license-server/install.sh?license_key=YOUR-LICENSE-KEY" | sh

```

--------------------------------

### Navigating to Application Directory (Non-Docker)

Source: https://docs.pwpush.com/docs/admin-dashboard

Navigate to the application's directory on a non-Docker installation to access console commands.

```bash
# Navigate to your application directory
cd /path/to/PasswordPusher
```

--------------------------------

### PostgreSQL Database Configuration

Source: https://docs.pwpush.com/docs/public-gateway

Example of setting the DATABASE_URL for PostgreSQL, which should be the same for both internal and gateway containers.

```yaml
# Both containers use the same DATABASE_URL
DATABASE_URL: postgres://pwpush_user:pwpush_passwd@postgres:5432/pwpush_db
```

--------------------------------

### List Active Pushes in Rust

Source: https://docs.pwpush.com/docs/json-api

This example shows how to retrieve a list of your active pushes. It requires authentication headers.

```rust
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.get("https://pwpush.com/p/active.json")
        .header("X-User-Email", "your-email@example.com")
        .header("X-User-Token", "MyAPIToken")
        .send()
        .await?;

    let active_pushes: Value = response.json().await?;
    println!("{:#?}", active_pushes);

    Ok(())
}

```

--------------------------------

### Apply Render Blueprint

Source: https://docs.pwpush.com/docs/installation

This command applies a Render Blueprint to deploy your application. Ensure you have the Render CLI installed and configured.

```bash
render blueprint apply
```

--------------------------------

### Retrieve Push by ID in Rust

Source: https://docs.pwpush.com/docs/json-api

This example demonstrates how to retrieve a specific push using its ID. It makes a GET request to the API and parses the JSON response.

```rust
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.get(&format!("https://pwpush.com/p/{}.json", push_id))
        .send()
        .await?;

    let push_data: Value = response.json().await?;
    println!("{:#?}", push_data);

    Ok(())
}

```

--------------------------------

### Separate Worker Container Setup with Docker Compose

Source: https://docs.pwpush.com/docs/background-jobs

Example Docker Compose configuration for running the main pwpush application and a dedicated pwpush-worker container separately. Ensure both services share the same database URL and configuration.

```yaml
services:
  # Main web application
  pwpush:
    image: docker.io/pglombardo/pwpush:stable
    environment:
      PWP__NO_WORKER: 'true'  # Disable worker in main container
      DATABASE_URL: postgres://user:pass@postgres:5432/pwpush
      # ... other configuration ...
    depends_on:
      - postgres

  # Dedicated worker container
  pwpush-worker:
    image: docker.io/pglombardo/pwpush-worker:stable
    environment:
      DATABASE_URL: postgres://user:pass@postgres:5432/pwpush
      # ... same configuration as main container ...
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    # ... database configuration ...


```

--------------------------------

### Create Push with Files (Authenticated)

Source: https://docs.pwpush.com/docs/json-api

This example demonstrates creating a push that includes files. It requires authentication with user email and token, and uses CPR for HTTP requests.

```cpp
#include <cpr/cpr.h>
#include <filesystem>

namespace fs = std::filesystem;

auto response = cpr::Post(
    cpr::Url{"https://pwpush.com/p.json"},
    cpr::Header{
        {"X-User-Email", "your-email@example.com"},
        {"X-User-Token", "MyAPIToken"}
    },
    cpr::Multipart{
        {"password[payload]", "my_secure_payload"},
        {"password[note]", "For New Employee ID 12345"},
        {"password[files][]", cpr::File{"file1.txt"}},
        {"password[files][]", cpr::File{"file2.txt"}}
    }
);


```

--------------------------------

### Create Push with Files (Go)

Source: https://docs.pwpush.com/docs/json-api

This snippet demonstrates how to create a push that includes files. It requires authentication via 'X-User-Email' and 'X-User-Token' headers.

```Go
package main

import (
    "bytes"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // Add text fields
    writer.WriteField("password[payload]", "my_secure_payload")
    writer.WriteField("password[note]", "For New Employee ID 12345")

    // Add files
    files := []string{"/path/to/file/file1.txt", "/path/to/file/file2.txt"}
    for _, filepath := range files {
        file, err := os.Open(filepath)
        if err != nil {
            panic(err)
        }
        defer file.Close()

        part, err := writer.CreateFormFile("password[files][]", filepath)
        if err != nil {
            panic(err)
        }
        io.Copy(part, file)
    }
    writer.Close()

    req, err := http.NewRequest("POST", "https://pwpush.com/p.json", body)
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", writer.FormDataContentType())
    req.Header.Set("X-User-Email", "your-email@example.com")
    req.Header.Set("X-User-Token", "MyAPIToken")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
}


```

--------------------------------

### Create Push with Files (C#)

Source: https://docs.pwpush.com/docs/json-api

This snippet demonstrates how to create a push that includes files. Authentication with user email and token is required.

```csharp
using var client = new HttpClient();
using var multipartContent = new MultipartFormDataContent();

// Add text fields
multipartContent.Add(new StringContent("my_secure_payload"), "password[payload]");
multipartContent.Add(new StringContent("For New Employee ID 12345"), "password[note]");

// Add files
var file1 = File.OpenRead("/path/to/file/file1.txt");
var file2 = File.OpenRead("/path/to/file/file2.txt");
multipartContent.Add(new StreamContent(file1), "password[files][]", "file1.txt");
multipartContent.Add(new StreamContent(file2), "password[files][]", "file2.txt");

client.DefaultRequestHeaders.Add("X-User-Email", "your-email@example.com");
client.DefaultRequestHeaders.Add("X-User-Token", "MyAPIToken");

var response = await client.PostAsync("https://pwpush.com/p.json", multipartContent);

```

--------------------------------

### Custom Domain Example

Source: https://docs.pwpush.com/docs/pushes

Example of how a custom domain is used to access the Password Pusher application.

```text
https://pwp.mycompany.org
```

--------------------------------

### Custom Domain Secret URL Example

Source: https://docs.pwpush.com/docs/pushes

Example of a secret URL generated when using a custom domain.

```text
https://pwp.mycompany.org/p/secret-token
```

--------------------------------

### Create Push with Files in Rust

Source: https://docs.pwpush.com/docs/json-api

This example demonstrates how to create a push that includes files. It requires authentication headers and uses multipart form data. Ensure you have the necessary `tokio` and `tokio-util` features enabled.

```rust
use reqwest;
use tokio::fs::File;
use tokio_util::codec::{BytesCodec, FramedRead};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let form = reqwest::multipart::Form::new()
        .text("password[payload]", "my_secure_payload")
        .text("password[note]", "For New Employee ID 12345");

    // Add files
    let file1 = File::open("/path/to/file/file1.txt").await?;
    let file2 = File::open("/path/to/file/file2.txt").await?;

    let stream1 = FramedRead::new(file1, BytesCodec::new());
    let stream2 = FramedRead::new(file2, BytesCodec::new());

    let form = form
        .part("password[files][]", reqwest::multipart::Part::stream(stream1))
        .part("password[files][]", reqwest::multipart::Part::stream(stream2));

    let response = client.post("https://pwpush.com/p.json")
        .header("X-User-Email", "your-email@example.com")
        .header("X-User-Token", "MyAPIToken")
        .multipart(form)
        .send()
        .await?;

    Ok(())
}

```

--------------------------------

### Create Push with Files (Python)

Source: https://docs.pwpush.com/docs/json-api

Demonstrates creating a push with files using Python's requests library. This requires authentication and properly formatted file data.

```python
import requests

headers = {
    "X-User-Email": "your-email@example.com",
    "X-User-Token": "MyAPIToken"
}

files = {
    "password[payload]": (None, "my_secure_payload"),
    "password[note]": (None, "For New Employee ID 12345"),
    "password[files][]": [
        ("file1.txt", open("/path/to/file/file1.txt", "rb")),
        ("file2.txt", open("/path/to/file/file2.txt", "rb"))
    ]
}

response = requests.post(
    "https://pwpush.com/p.json",
    headers=headers,
    files=files
)
```

--------------------------------

### Create Authenticated Push with Files

Source: https://docs.pwpush.com/docs/json-api

Create a push that includes files and requires authentication. Ensure you replace 'your-email@example.com' and 'MyAPIToken' with your actual credentials. The file paths must be valid.

```ruby
require 'net/http'
require 'uri'
require 'json'

uri = URI('https://pwpush.com/p.json')
request = Net::HTTP::Post.new(uri)
request['X-User-Email'] = 'your-email@example.com'
request['X-User-Token'] = 'MyAPIToken'

form_data = [
  ['password[payload]', 'my_secure_payload'],
  ['password[note]', 'For New Employee ID 12345'],
  ['password[files][]', File.open('/path/to/file/file1.txt')],
  ['password[files][]', File.open('/path/to/file/file2.txt)']
]

request.set_form form_data, 'multipart/form-data'
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
```

--------------------------------

### Backup SQLite Database from Host

Source: https://docs.pwpush.com/docs/pro-self-hosted-backups

Use the SQLite .backup command to create a consistent snapshot of the database file directly from the host system. Ensure the path to the database file is correct.

```bash
# Replace with your actual DB path (e.g. Docker volume mount or container path)
sqlite3 /path/to/production.sqlite3 ".backup '/backups/pwpush-$(date +%Y-%m-%d).db'"
```

--------------------------------

### Get Active Pushes List (Swift)

Source: https://docs.pwpush.com/docs/json-api

Retrieves a list of all active pushes associated with the authenticated user. It sends a GET request to the active pushes endpoint.

```swift
let url = URL(string: "https://pwpush.com/p/active.json")!
var request = URLRequest(url: url)
```

--------------------------------

### Gmail Authentication Error Example

Source: https://docs.pwpush.com/docs/troubleshooting-email

Example of a Net::SMTPAuthenticationError indicating that Gmail requires an application-specific password. This error occurs when using the regular account password instead.

```text
Net::SMTPAuthenticationError: 534-5.7.9 Application-specific password required.

```

--------------------------------

### pgloader Migration Script Example

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Defines the migration parameters for pgloader, including source and target databases, table casting, and schema renaming. Replace placeholders with your actual database credentials and hostnames.

```sql
LOAD DATABASE
    FROM mysql://MYSQL_USER:MYSQL_PASS@MYSQL_HOST:3306/pwpush_db
    INTO postgresql://pwpush_user:POSTGRES_PASS@POSTGRES_HOST:5432/pwpush_db

WITH include drop, create tables, create indexes, reset sequences,
     workers = 2, concurrency = 1,
     data only, preserve index names

SET work_mem to '128MB',
    maintenance_work_mem to '512 MB'

CAST type datetime to timestamp drop default drop not null using zero-dates-to-null,
     type date drop not null drop default using zero-dates-to-null,
     type tinyint to boolean using tinyint-to-boolean

ALTER SCHEMA 'pwpush_db' RENAME TO 'public';

```

--------------------------------

### Start Password Pusher Pro with Docker Compose

Source: https://docs.pwpush.com/docs/pro-self-hosted-azure

Starts the Password Pusher Pro services in detached mode and displays the last 100 log lines for monitoring.

```bash
docker compose up -d
docker compose logs --tail=100 pwpush-pro

```

--------------------------------

### Create QR Code Push

Source: https://docs.pwpush.com/docs/json-api

This example shows how to create a push that contains QR code content. CPR is used for the HTTP POST request.

```cpp
auto response = cpr::Post(
    cpr::Url{"https://pwpush.com/p.json"},
    cpr::Multipart{
        {"password[kind]", "qr"},
        {"password[payload]", "QR Code Content is here"}
    }
);


```

--------------------------------

### Create and Use Docker Buildx Builder Instance

Source: https://docs.pwpush.com/docs/building-docker

Create a new Docker Buildx builder instance named 'multiplatform' and set it as the current builder. This is often necessary for multi-platform builds.

```bash
docker buildx create --name multiplatform --use
docker buildx inspect --bootstrap

```

--------------------------------

### Example Custom CSS Overrides

Source: https://docs.pwpush.com/docs/rebranding

This CSS snippet provides examples for overriding the navbar background, styling custom buttons, and fixing theme-specific font issues. Use `!important` sparingly.

```css
/* Override navbar background */
.navbar {
  background-color: #your-brand-color !important;
}

/* Custom button styling */
.btn-primary {
  border-radius: 8px;
  font-weight: 600;
}

/* Fix theme-specific font issues */
body {
  font-family: 'Your Font', sans-serif;
}
```

--------------------------------

### PWPush API Usage Examples in Kotlin

Source: https://docs.pwpush.com/docs/json-api

Demonstrates how to call the various PWPush API functions defined previously within a suspend function context.

```kotlin
suspend fun main() {
    // Create an anonymous push
    createPush("my secret password")

    // Create an authenticated push with files
    createAuthenticatedPush(
        payload = "secure content",
        note = "For employee onboarding",
        files = listOf(File("document1.pdf"), File("document2.pdf")),
        email = "your-email@example.com",
        apiToken = "your-api-token"
    )

    // Create a URL push
    createUrlPush("https://example.com")

    // Create a QR code push
    createQRPush("QR Code content here")

    // Get active pushes
    val activePushes = getActivePushes(
        email = "your-email@example.com",
        apiToken = "your-api-token"
    )
}
```

--------------------------------

### Start Password Pusher with Docker Compose

Source: https://docs.pwpush.com/docs/installation

This command starts the Password Pusher server in detached mode using Docker Compose. Ensure you have configured the necessary Docker Compose files beforehand.

```bash
docker compose up -d

```

--------------------------------

### Create a New User

Source: https://docs.pwpush.com/docs/application-console

This command creates a new user record in the database. Ensure you provide a strong password and confirm it. This is typically used for setting up new accounts programmatically.

```ruby
User.create(
  email: 'user@example.com',
  password: 'secure_password',
  password_confirmation: 'secure_password'
)

```

--------------------------------

### Start Maintenance Mode

Source: https://docs.pwpush.com/docs/background-jobs

Run this command to enable maintenance mode for the application. This will cause the application to refuse serving pages and display a maintenance page instead.

```bash
./bin/rake maintenance:start

```

--------------------------------

### Domain Verification Error Log Example

Source: https://docs.pwpush.com/docs/pro-self-hosted-configuration

An example of an error message logged by Password Pusher Pro when a user's email domain is not verified for their Azure AD account. This indicates a potential security issue or misconfiguration.

```log
E, [2026-03-12T17:29:53.729156 #22] ERROR -- omniauth: (microsoft_graph) Authentication failure!
The email domain 'example.com' is not a verified domain for this Azure AD account.
You can either:
  * Update the user's email to match the principal domain 'contoso.com'
  * Skip verification on the 'example.com' domain (not recommended)
  * Disable verification with 'skip_domain_verification: true' (NOT RECOMMENDED!)
: OmniAuth::MicrosoftGraph::DomainVerificationError, ...
```

--------------------------------

### Install Password Pusher Pro Helm Chart (Advanced Edition)

Source: https://docs.pwpush.com/docs/pro-self-hosted-kubernetes

Installs the Password Pusher Pro Helm chart for the Advanced edition using a custom values file and specifying license and image pull secret.

```bash
helm install my-push pwpush-pro/pwpush-pro \
  -f values-advanced.yaml \
  --set license.key=YOUR_LICENSE_KEY \
  --set license.region=YOUR_REGION \
  --set imagePullSecrets[0].name=regcred

```

--------------------------------

### Follow Application Logs

Source: https://docs.pwpush.com/docs/pro-self-hosted-operations

Continuously streams the logs for the 'pwpush-pro' service. Press Ctrl+C to stop following.

```bash
docker compose logs -f pwpush-pro
```

--------------------------------

### Install Password Pusher Pro Helm Chart (Enterprise Edition)

Source: https://docs.pwpush.com/docs/pro-self-hosted-kubernetes

Installs the Password Pusher Pro Helm chart for the Enterprise edition using a custom values file, specifying license, image pull secret, and existing PostgreSQL secret.

```bash
helm install my-push pwpush-pro/pwpush-pro \
  -f values-enterprise.yaml \
  --set license.key=YOUR_LICENSE_KEY \
  --set license.region=YOUR_REGION \
  --set imagePullSecrets[0].name=regcred \
  --set postgresql.auth.existingSecret=my-push-pwpush-pro

```

--------------------------------

### Create QR Code Push (Go)

Source: https://docs.pwpush.com/docs/json-api

This snippet demonstrates creating a push that will be represented as a QR code. It sets 'password[kind]' to 'qr' and the content for the QR code in 'password[payload]'.

```Go
data := url.Values{}
data.Set("password[kind]", "qr")
data.Set("password[payload]", "QR Code Content is here")

resp, err := http.PostForm("https://pwpush.com/p.json", data)


```

--------------------------------

### Create Push with Files (PowerShell)

Source: https://docs.pwpush.com/docs/json-api

This snippet demonstrates how to create a push that includes files. It requires authentication with user email and token.

```powershell
$headers = @{
    'X-User-Email' = 'your-email@example.com'
    'X-User-Token' = 'MyAPIToken'
}

$form = @{
    'password[payload]' = 'my_secure_payload'
    'password[note]' = 'For New Employee ID 12345'
    'password[files][]' = Get-Item -Path @(
        '/path/to/file/file1.extension',
        '/path/to/file/file2.extension'
    )
}

$response = Invoke-RestMethod -Uri 'https://pwpush.com/p.json' -Method Post -Headers $headers -Form $form
```

--------------------------------

### Get Expired Pushes

Source: https://docs.pwpush.com/docs/json-api

Retrieves a list of all expired pushes associated with the authenticated user.

```APIDOC
## GET /p/expired.json

### Description
Retrieves a list of expired pushes for the authenticated user.

### Method
GET

### Endpoint
https://pwpush.com/p/expired.json

### Headers
- **X-User-Email** (string) - Required - The user's email address.
- **X-User-Token** (string) - Required - The user's API token.

### Response
#### Success Response (200)
- An array of PushResponse objects, each containing details of an expired push.

#### Response Example
```json
[
  {
    "url_token": "expired_push_1_token",
    "payload": "old content 1",
    "expire_after_days": 30,
    "expire_after_views": 10,
    "expired": true,
    "created_at": "2023-10-20T10:00:00Z",
    "updated_at": "2023-10-27T10:00:00Z"
  }
]
```
```

--------------------------------

### Configure Ingress and TLS for Password Pusher Pro

Source: https://docs.pwpush.com/docs/pro-self-hosted-kubernetes

Example configuration for enabling Ingress and TLS for Password Pusher Pro, assuming cert-manager and an nginx Ingress controller.

```yaml
ingress:
  enabled: true
  className: nginx
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
  hosts:
    - host: push.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: push-tls
      hosts:
        - push.example.com

```

--------------------------------

### Get Active Pushes

Source: https://docs.pwpush.com/docs/api-v1

Retrieves a list of all currently active pushes associated with the authenticated user.

```APIDOC
## GET /p/active.json

### Description
Retrieves a list of all currently active pushes associated with the authenticated user.

### Method
GET

### Endpoint
https://pwpush.com/p/active.json

### Parameters
#### Headers
- **X-User-Email** (string) - Required - The user's email address.
- **X-User-Token** (string) - Required - The user's API token.

### Response
#### Success Response (200)
- **(List<JsonObject>)** - A list of active push objects.

### Response Example
```json
[
  {
    "example": "push object 1"
  },
  {
    "example": "push object 2"
  }
]
```
```

--------------------------------

### Create URL Push

Source: https://docs.pwpush.com/docs/json-api

Create a push specifically for a URL. Ensure HTTP::Request::Common is installed.

```perl
my $request = POST 'https://pwpush.com/p.json',
    Content_Type => 'form-data',
    Content => [
        'password[kind]' => 'url',
        'password[payload]' => 'https://the0x00.dev'
    ];

my $response = $ua->request($request);


```

--------------------------------

### Set Multiple Environment Variables and Run Console (Docker)

Source: https://docs.pwpush.com/docs/application-console

Configure multiple environment variables, such as RAILS_ENV and DATABASE_URL, before starting the console in a Dockerized environment.

```bash
docker compose exec -e RAILS_ENV=development -e DATABASE_URL=sqlite3:db/development.sqlite3 pwpush bin/pwpush console
```

--------------------------------

### Traefik Service Labels for Proxying

Source: https://docs.pwpush.com/docs/proxies

Example Traefik labels to configure routing and port for the Password Pusher service.

```yaml
services:
  pwpush:
    labels:
      - "traefik.http.services.pwpush.loadbalancer.server.port=5100"
      - "traefik.http.routers.pwpush.rule=Host(`pwpush.example.com`)"
      - "traefik.http.routers.pwpush.entrypoints=websecure"
      - "traefik.http.routers.pwpush.tls.certresolver=letsencrypt"

```

--------------------------------

### Run Migration with pgloader Config File

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Initiates the database migration using a previously created pgloader configuration file. This method offers more control over the migration process.

```bash
pgloader pwpush-migrate.load

```

--------------------------------

### Complete Upgrade Command Sequence

Source: https://docs.pwpush.com/docs/upgrading

A sequence of commands to perform a full upgrade: pull the latest image, stop the old container, and start a new one. Followed by checking logs.

```bash
# Pull latest image, stop old container, start new container
docker compose pull && docker compose down && docker compose up -d
```

```bash
# Check logs
docker compose logs -f pwpush
```

--------------------------------

### Create Push with Files (Authenticated)

Source: https://docs.pwpush.com/docs/json-api

This snippet demonstrates creating a push that includes files. It requires authentication with user email and token, and a helper class for multipart form data.

```java
import java.nio.file.Path;

String boundary = "---boundary---" + System.currentTimeMillis();
Path file1 = Path.of("/path/to/file/file1.txt");
Path file2 = Path.of("/path/to/file/file2.txt");

MultipartBodyPublisher publisher = new MultipartBodyPublisher()
    .addPart("password[payload]", "my_secure_payload")
    .addPart("password[note]", "For New Employee ID 12345")
    .addPart("password[files][]", file1)
    .addPart("password[files][]", file2);

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://pwpush.com/p.json"))
    .header("X-User-Email", "your-email@example.com")
    .header("X-User-Token", "MyAPIToken")
    .header("Content-Type", "multipart/form-data; boundary=" + boundary)
    .POST(publisher.build())
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

```

--------------------------------

### Run Migration with pgloader Command Line

Source: https://docs.pwpush.com/docs/mysql-to-postgresql-migration

Executes the database migration directly from the command line using pgloader. Ensure you replace the placeholder credentials and hostnames with your actual values. Adjust ports if non-standard ones are used.

```bash
pgloader mysql://MYSQL_USER:MYSQL_PASS@127.0.0.1:3306/pwpush_db postgresql://PG_USER:PG_PASS@127.0.0.1:5432/pwpush_db

```
Tokens:
Raw