┌─────────────────────────────────────────────┐
│         AnyTask Worker Architecture         │
└─────────────────────────────────────────────┘

1. Worker polls API for tasks assigned to agent
2. Matches tasks to workflows based on triggers
3. Executes workflow steps sequentially
4. Uses AI (Claude) for analysis and implementation
5. Updates task with progress and results

export ANYT_API_KEY=anyt_agent_xxxxxxxxxxxxx

anyt init --workspace-id 123 --identifier DEV

# Start with all built-in workflows
anyt worker start --agent-id agent-xxx

# Start with specific workflow
anyt worker start --workflow local_dev --agent-id agent-xxx

# Start with custom workflows directory
anyt worker start --workflows /path/to/workflows --agent-id agent-xxx

anyt task add "Implement user login" --status todo

anyt worker start [OPTIONS]

# Start with default settings
anyt worker start --agent-id agent-xxx

# Custom poll interval
anyt worker start --agent-id agent-xxx --poll-interval 10

# Specific workflow only
anyt worker start --workflow local_dev --agent-id agent-xxx

# Custom workflows directory
anyt worker start --workflows /custom/workflows --agent-id agent-xxx

anyt worker list-workflows [OPTIONS]

anyt worker list-workflows

Available Workflows
┌─────────────────────┬───────────────────────────┬──────────────────┐
│ Name                │ Description               │ Triggers         │
├─────────────────────┼───────────────────────────┼──────────────────┤
│ Local Development   │ Direct implementation     │ task_created,    │
│                     │ on current repository     │ task_updated     │
├─────────────────────┼───────────────────────────┼──────────────────┤
│ Feature Development │ Automated feature         │ task_created,    │
│                     │ implementation            │ task_updated     │
└─────────────────────┴───────────────────────────┴──────────────────┘

anyt worker validate-workflow <workflow_file>

anyt worker validate-workflow .anyt/workflows/my_workflow.yaml

✓ Workflow is valid: My Custom Workflow
  Description: Custom implementation workflow
  Jobs: 1
    - implement: 8 steps

timeout-minutes: 30
model: claude-haiku-4-5-20251001

timeout-minutes: 60
model: claude-haiku-4-5-20251001

timeout-minutes: 60
model: claude-haiku-4-5-20251001

# Workflow metadata
name: My Custom Workflow
description: Description of what this workflow does

# Trigger conditions
"on":
  task_created:
    labels: ["custom-label"]
  task_updated:
    status: ["todo"]
    labels: ["custom-label"]

# Jobs to execute
jobs:
  my_job:
    name: Job Display Name
    runs-on: local
    timeout-minutes: 60

    steps:
      - name: Step 1
        uses: anyt/checkout@v1
        with:
          branch: main

      - name: Step 2
        uses: anyt/claude-code@v1
        with:
          prompt: "Implement: ${{ task.description }}"

      - name: Step 3
        uses: anyt/task-update@v1
        with:
          status: done

    # Optional failure handling
    on-failure:
      - name: Handle error
        uses: anyt/task-update@v1
        with:
          note: "Failed: ${{ failure.message }}"

name: Simple Workflow
"on":
  task_created:
jobs:
  run:
    name: Run Task
    steps:
      - name: Do work
        run: echo "Hello, ${{ task.title }}"

name: string (required)
description: string (optional)
"on": WorkflowOn (required)
jobs: Dict[str, WorkflowJob] (required)
on-failure: List[WorkflowStep] (optional)

"on":
  task_created:
    labels: ["feature", "bug"]       # Match tasks with these labels
    status: ["todo"]                 # Match tasks with this status

  task_updated:
    status: ["todo", "in_progress"]  # Match status changes
    labels: ["urgent"]               # Match tasks with this label

# Match any task with "feature" label
"on":
  task_created:
    labels: ["feature"]

# Match tasks updated to "todo" status
"on":
  task_updated:
    status: ["todo"]

# Match tasks with BOTH conditions
"on":
  task_created:
    labels: ["feature"]
    status: ["todo"]

# Multiple triggers
"on":
  task_created:
    labels: ["urgent"]
  task_updated:
    status: ["todo"]

jobs:
  job_name:
    name: Display Name
    runs-on: local                  # Currently only "local" supported
    timeout-minutes: 60             # Job timeout (default: 60)
    steps: List[WorkflowStep]

- name: Step Name
  uses: anyt/action-name@v1
  id: step_id                       # Optional, for referencing outputs
  with:
    param1: value1
    param2: value2
  if: condition                     # Optional conditional
  continue-on-error: false          # Optional, default: false
  timeout-minutes: 30               # Optional, default: 30

- name: Run Command
  run: make test
  continue-on-error: true
  timeout-minutes: 10

- name: Deploy to production
  uses: anyt/deploy@v1
  if: ${{ task.labels contains 'production' }}

on-failure:
  - name: Log error
    uses: anyt/task-update@v1
    with:
      note: "Failed at: ${{ failure.step }}"

  - name: Notify team
    run: echo "Task failed" | mail -s "Failure" [email protected]

- name: Checkout code
  uses: anyt/checkout@v1
  with:
    branch: main          # Branch to checkout (default: current)
    clean: true           # Clean working directory (default: false)
    create: false         # Create branch if doesn't exist (default: false)

- name: Commit changes
  uses: anyt/git-commit@v1
  with:
    message: |
      feat: Implement feature

      Task: ${{ task.identifier }}
    add: all              # What to add: "all" or specific files

- name: Analyze task
  uses: anyt/claude-prompt@v1
  id: analysis
  with:
    model: claude-haiku-4-5-20251001  # Model to use
    prompt: |
      Analyze this task:
      ${{ task.description }}
    output: result                     # Output variable name (default: result)

- name: Implement feature
  uses: anyt/claude-code@v1
  id: implementation
  with:
    model: claude-haiku-4-5-20251001
    prompt: |
      Implement: ${{ task.description }}
    stream: true                               # Stream output (default: false)
    dangerously-skip-permissions: true         # Skip permission prompts (default: false)

- name: Update task
  uses: anyt/task-update@v1
  with:
    status: done                    # New status (optional)
    note: |                         # Note to add (optional)
      Implementation completed
    timestamp: true                 # Add timestamp to note (default: false)

- name: Analyze task
  uses: anyt/task-analyze@v1
  with:
    model: claude-haiku-4-5-20251001

- name: Get task details
  uses: anyt/task-detail@v1
  id: details

- name: Cache dependencies
  uses: anyt/cache@v1
  with:
    path: |
      ~/.cache/uv
      node_modules
    key: deps-${{ hashFiles('**/requirements.txt') }}
    restore-keys: |
      deps-

- name: Run tests
  uses: anyt/test@v1
  with:
    framework: pytest              # Framework: pytest, jest, etc.
    path: tests/                   # Test directory
    args: -v --cov                 # Additional arguments

- name: Build project
  uses: anyt/build@v1
  with:
    command: make build           # Build command

${{ task.identifier }}         # DEV-42
${{ task.title }}              # Task title
${{ task.description }}        # Full task description
${{ task.status }}             # current status
${{ task.labels }}             # List of labels
${{ task.priority }}           # Priority value (-2 to 2)
${{ task.owner }}              # Owner ID

steps:
  - name: Analyze
    uses: anyt/claude-prompt@v1
    id: analysis
    with:
      prompt: "Analyze: ${{ task.description }}"
      output: result

  - name: Implement
    uses: anyt/claude-code@v1
    with:
      prompt: |
        Based on analysis:
        ${{ steps.analysis.outputs.result }}

on-failure:
  - name: Report error
    uses: anyt/task-update@v1
    with:
      note: |
        Failed at: ${{ failure.step }}
        Error: ${{ failure.message }}

- name: Use API key
  run: echo "Key: ${{ env.API_KEY }}"

key: deps-${{ hashFiles('**/package.json') }}

- name: Complex example
  uses: anyt/claude-code@v1
  with:
    prompt: |
      Task: ${{ task.identifier }}
      Title: ${{ task.title }}

      Previous analysis:
      ${{ steps.analysis.outputs.result }}

      Labels: ${{ task.labels }}
      Priority: ${{ task.priority }}

anyt worker secret set SECRET_NAME --value "secret-value"

anyt worker secret set SECRET_NAME
# Enter value for secret 'SECRET_NAME': _

# Show masked
anyt worker secret get SECRET_NAME
# Output: SECRET_NAME: sec******lue

# Show full value
anyt worker secret get SECRET_NAME --show
# Output: SECRET_NAME: secret-value

anyt worker secret delete SECRET_NAME

- name: Deploy
  run: |
    export API_KEY="${{ secrets.API_KEY }}"
    deploy.sh

anyt worker secret test "KEY=\${{ secrets.API_KEY }}"

1. Worker polls for tasks
2. Matches task to workflow triggers
3. Creates attempt record
4. Executes steps sequentially
5. Updates task with progress
6. Stores artifacts
7. Marks attempt as complete/failed

anyt attempt list DEV-42

anyt attempt show attempt-123

anyt artifact download artifact-456 --output result.json

name: Bug Fix
description: Automated bug fix workflow

"on":
  task_created:
    labels: ["bug"]

jobs:
  fix:
    name: Fix Bug
    timeout-minutes: 30
    steps:
      - name: Analyze bug
        uses: anyt/claude-prompt@v1
        id: analysis
        with:
          prompt: |
            Analyze this bug:
            ${{ task.description }}

      - name: Fix bug
        uses: anyt/claude-code@v1
        with:
          prompt: |
            Fix: ${{ task.description }}

            Analysis: ${{ steps.analysis.outputs.result }}

      - name: Run tests
        run: make test

      - name: Commit
        uses: anyt/git-commit@v1
        with:
          message: "fix: ${{ task.title }}"

      - name: Complete
        uses: anyt/task-update@v1
        with:
          status: done
          note: "Bug fixed and tested"

name: Documentation Update
description: Update documentation automatically

"on":
  task_created:
    labels: ["docs"]

jobs:
  update_docs:
    name: Update Documentation
    steps:
      - name: Checkout
        uses: anyt/checkout@v1

      - name: Generate docs
        uses: anyt/claude-code@v1
        with:
          prompt: |
            Update documentation for: ${{ task.description }}

      - name: Commit
        uses: anyt/git-commit@v1
        with:
          message: "docs: ${{ task.title }}"

      - name: Complete
        uses: anyt/task-update@v1
        with:
          status: done

name: Feature with Review
description: Feature development with review checkpoint

"on":
  task_created:
    labels: ["feature"]

jobs:
  develop:
    name: Develop Feature
    timeout-minutes: 90
    steps:
      # Phase 1: Analysis
      - name: Analyze requirements
        uses: anyt/claude-prompt@v1
        id: requirements
        with:
          prompt: |
            Analyze requirements for:
            ${{ task.description }}

      - name: Post analysis
        uses: anyt/task-update@v1
        with:
          note: |
            ## Requirements Analysis
            ${{ steps.requirements.outputs.result }}

      # Phase 2: Design
      - name: Create design
        uses: anyt/claude-prompt@v1
        id: design
        with:
          prompt: |
            Create technical design for:
            ${{ steps.requirements.outputs.result }}

      - name: Post design
        uses: anyt/task-update@v1
        with:
          note: |
            ## Technical Design
            ${{ steps.design.outputs.result }}

      # Phase 3: Implementation
      - name: Implement feature
        uses: anyt/claude-code@v1
        with:
          prompt: |
            Implement based on design:
            ${{ steps.design.outputs.result }}

      # Phase 4: Testing
      - name: Run tests
        run: make test

      - name: Lint code
        run: make lint

      # Phase 5: Completion
      - name: Commit
        uses: anyt/git-commit@v1
        with:
          message: |
            feat: ${{ task.title }}

            ${{ steps.design.outputs.result }}

      - name: Complete
        uses: anyt/task-update@v1
        with:
          status: done
          note: "Feature implemented and tested"

    on-failure:
      - name: Report failure
        uses: anyt/task-update@v1
        with:
          note: |
            ❌ Failed at: ${{ failure.step }}
            Error: ${{ failure.message }}

name: Conditional Deployment
"on":
  task_updated:
    status: ["done"]

jobs:
  deploy:
    name: Deploy if Production
    steps:
      - name: Check environment
        uses: anyt/task-detail@v1
        id: details

      - name: Deploy to staging
        run: deploy-staging.sh
        if: ${{ task.labels contains 'staging' }}

      - name: Deploy to production
        run: deploy-production.sh
        if: ${{ task.labels contains 'production' }}

on-failure:
  - name: Update task
    uses: anyt/task-update@v1
    with:
      note: |
        ❌ Failed: ${{ failure.step }}
        ${{ failure.message }}

- name: Optional linting
  run: make lint
  continue-on-error: true

jobs:
  quick_task:
    timeout-minutes: 15    # Short tasks

  complex_task:
    timeout-minutes: 120   # Complex tasks

# Good
prompt: |
  Implement: ${{ task.description }}
  Labels: ${{ task.labels }}

# Bad
prompt: "Implement the task"

- name: Analyze
  id: analysis
  uses: anyt/claude-prompt@v1
  with:
    output: plan

- name: Implement
  uses: anyt/claude-code@v1
  with:
    prompt: "Follow plan: ${{ steps.analysis.outputs.plan }}"

- name: Commit
  uses: anyt/git-commit@v1
  with:
    message: |
      feat: ${{ task.title }}

      Task: ${{ task.identifier }}

      🤖 Generated with Claude Code

- name: Post progress
  uses: anyt/task-update@v1
  with:
    note: |
      ## Implementation Progress

      Completed: Step 1, 2, 3
      Next: Testing
    timestamp: true

# Validate syntax
anyt worker validate-workflow .anyt/workflows/my_workflow.yaml

# Use dry-run actions for testing
- uses: anyt/dry-run-claude-code@v1

name: My Workflow
description: |
  This workflow does X, Y, and Z.

  Triggers on:
  - New tasks with "feature" label
  - Tasks updated to "todo" status

  Steps:
  1. Analyze requirements
  2. Implement changes
  3. Run tests
  4. Deploy

# Solution: Set the API key
export ANYT_API_KEY=anyt_agent_xxxxxxxxxxxxx

# Solution: Provide agent ID
anyt worker start --agent-id agent-xxx

# Solution: Initialize workspace
anyt init --workspace-id 123 --identifier DEV

# Verify task has correct label
anyt task show DEV-42

# Check workflow triggers
anyt worker list-workflows

ls .anyt/workflows/

# List attempts
anyt attempt list DEV-42

# Show attempt details
anyt attempt show attempt-123

# Solution: Set the secret
anyt worker secret set API_KEY --value "your-key"

# Verify
anyt worker secret get API_KEY

# Recommended: Install script
curl -fsSL https://anyt.dev/install.sh | sh

# Verify installation
anyt --version

# Install Node.js (if not already installed)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt-get install -y nodejs

# Install Claude Code CLI
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# Create dedicated user for worker
sudo useradd -r -m -s /bin/bash -d /var/lib/anyt-worker anyt-worker

# Create necessary directories
sudo mkdir -p /etc/anyt/{environments,workflows/{production,staging,development},systemd}
sudo mkdir -p /opt/projects/{production,staging,development}
sudo mkdir -p /var/log/anyt

# Set ownership
sudo chown -R anyt-worker:anyt-worker /var/lib/anyt-worker
sudo chown -R anyt-worker:anyt-worker /opt/projects
sudo chown -R anyt-worker:anyt-worker /var/log/anyt

# API Configuration
ANYT_API_KEY=anyt_agent_production_xxx_yyy_zzz
ANYT_API_URL=https://api.anyt.dev
AGENT_ID=agent-prod-001

# Workflow Configuration
WORKFLOWS_DIR=/etc/anyt/workflows/production
POLL_INTERVAL=5
MAX_BACKOFF=60

# Git Configuration
GIT_AUTHOR_NAME="AnyTask Worker (Production)"
GIT_AUTHOR_EMAIL="[email protected]"
GIT_COMMITTER_NAME="AnyTask Worker (Production)"
GIT_COMMITTER_EMAIL="[email protected]"

sudo chmod 600 /etc/anyt/environments/*.env
sudo chown anyt-worker:anyt-worker /etc/anyt/environments/*.env

# Switch to service user
sudo -u anyt-worker bash

# Navigate to project directory
cd /opt/projects/production

# Initialize git repository (if not already a git repo)
git init
git remote add origin https://github.com/company/production-repo.git
git fetch origin
git checkout main

# Initialize AnyTask workspace
anyt init --workspace-id 1 --identifier PROD

# Configure workspace
cat > .anyt/anyt.json << EOF
{
  "workspace_id": "1",
  "name": "Production",
  "identifier": "PROD",
  "api_url": "https://api.anyt.dev",
  "agent_key": "anyt_agent_production_xxx_yyy_zzz",
  "current_project_id": 1
}
EOF

# Verify configuration
anyt auth whoami

[Unit]
Description=AnyTask Worker - Production
Documentation=https://docs.anyt.dev/worker-system/
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=anyt-worker
Group=anyt-worker
WorkingDirectory=/opt/projects/production

# Environment configuration
EnvironmentFile=/etc/anyt/environments/production.env

# Start worker
ExecStart=/home/anyt-worker/.local/bin/anyt worker start \
    --agent-id ${AGENT_ID} \
    --workflows ${WORKFLOWS_DIR} \
    --poll-interval ${POLL_INTERVAL} \
    --max-backoff ${MAX_BACKOFF}

# Restart policy
Restart=always
RestartSec=10
StartLimitInterval=300
StartLimitBurst=5

# Logging
StandardOutput=journal
StandardError=journal
SyslogIdentifier=anyt-worker-prod

# Security hardening
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/projects/production /var/log/anyt
ReadOnlyPaths=/etc/anyt

# Resource limits
LimitNOFILE=65536
LimitNPROC=4096
MemoryMax=4G
CPUQuota=200%

[Install]
WantedBy=multi-user.target

# Reload systemd
sudo systemctl daemon-reload

# Enable service to start on boot
sudo systemctl enable anyt-worker-prod

# Start service
sudo systemctl start anyt-worker-prod

# Check status
sudo systemctl status anyt-worker-prod

# View logs
journalctl -u anyt-worker-prod -f

name: Production Feature Development
description: Automated feature implementation with full testing and review

"on":
  task_created:
    labels: ["feature"]
    status: ["todo"]

jobs:
  develop:
    name: Develop and Test Feature
    timeout-minutes: 90

    steps:
      # Analysis Phase
      - name: Analyze Requirements
        uses: anyt/claude-prompt@v1
        id: analysis
        with:
          model: claude-sonnet-4-5-20250929
          prompt: |
            Analyze requirements for: ${{ task.description }}

            Provide:
            1. Technical approach
            2. Dependencies and prerequisites
            3. Testing strategy
            4. Potential risks

      - name: Post Analysis
        uses: anyt/task-update@v1
        with:
          note: |
            ## Requirements Analysis
            ${{ steps.analysis.outputs.result }}
          timestamp: true

      # Implementation Phase
      - name: Checkout Code
        uses: anyt/checkout@v1
        with:
          branch: main
          clean: true

      - name: Cache Dependencies
        uses: anyt/cache@v1
        with:
          path: |
            ~/.cache/uv
            node_modules
          key: deps-${{ hashFiles('**/requirements.txt', '**/package.json') }}

      - name: Implement Feature
        uses: anyt/claude-code@v1
        id: implementation
        with:
          model: claude-sonnet-4-5-20250929
          prompt: |
            Implement the following feature based on analysis:

            ${{ steps.analysis.outputs.result }}

            Requirements:
            ${{ task.description }}

            Follow best practices:
            - Write comprehensive tests
            - Add documentation
            - Follow project code style
            - Handle errors gracefully

      # Testing Phase
      - name: Lint Code
        run: make lint
        continue-on-error: false
        timeout-minutes: 5

      - name: Run Unit Tests
        run: make test
        continue-on-error: false
        timeout-minutes: 15

      - name: Run Integration Tests
        run: make test-integration
        continue-on-error: false
        timeout-minutes: 20

      # Finalization Phase
      - name: Commit Changes
        uses: anyt/git-commit@v1
        with:
          message: |
            feat(${{ task.identifier }}): ${{ task.title }}

            ${{ steps.implementation.outputs.summary }}

            Task: ${{ task.identifier }}

            🤖 Generated with Claude Code

      - name: Mark Complete
        uses: anyt/task-update@v1
        with:
          status: done
          note: |
            ✅ Feature implemented and tested

            ## Summary
            ${{ steps.implementation.outputs.summary }}

            ## Files Modified
            ${{ steps.implementation.outputs.files_modified }}

            All tests passing.
          timestamp: true

    on-failure:
      - name: Report Failure
        uses: anyt/task-update@v1
        with:
          status: todo
          note: |
            ❌ Automated implementation failed

            **Failed Step**: ${{ failure.step }}
            **Error**: ${{ failure.message }}

            Please review and implement manually or update requirements.
          timestamp: true

      - name: Create Bug Task
        uses: anyt/task-create@v1
        with:
          title: "Fix: Failed automated implementation of ${{ task.identifier }}"
          description: |
            Automated workflow failed for: ${{ task.title }}

            Original task: ${{ task.identifier }}
            Failed step: ${{ failure.step }}
            Error: ${{ failure.message }}

            Review workflow execution and fix issues.
          labels: ["bug", "worker-failure"]
          priority: 1
          depends_on: ${{ task.identifier }}

name: Production Bug Fix
description: Automated bug fix with regression testing

"on":
  task_created:
    labels: ["bug", "production"]
    status: ["todo"]

jobs:
  fix:
    name: Fix Bug
    timeout-minutes: 60

    steps:
      - name: Analyze Bug
        uses: anyt/claude-prompt@v1
        id: analysis
        with:
          model: claude-sonnet-4-5-20250929
          prompt: |
            Analyze this production bug:
            ${{ task.description }}

            Provide:
            1. Root cause analysis
            2. Fix approach
            3. Testing strategy
            4. Prevention measures

      - name: Checkout Code
        uses: anyt/checkout@v1
        with:
          branch: main
          clean: true

      - name: Implement Fix
        uses: anyt/claude-code@v1
        with:
          model: claude-sonnet-4-5-20250929
          prompt: |
            Fix this bug: ${{ task.description }}

            Analysis: ${{ steps.analysis.outputs.result }}

            Requirements:
            - Add regression tests
            - Update documentation
            - Verify fix doesn't break existing functionality

      - name: Run Full Test Suite
        run: make test-all
        timeout-minutes: 30

      - name: Commit Fix
        uses: anyt/git-commit@v1
        with:
          message: |
            fix(${{ task.identifier }}): ${{ task.title }}

            Root cause: ${{ steps.analysis.outputs.result }}

            Task: ${{ task.identifier }}

            🤖 Generated with Claude Code

      - name: Mark Complete
        uses: anyt/task-update@v1
        with:
          status: done
          note: |
            ✅ Bug fixed and tested

            All tests passing, including new regression tests.

    on-failure:
      - name: Escalate
        uses: anyt/task-update@v1
        with:
          status: todo
          priority: 2  # Increase priority
          note: |
            ⚠️ Automated fix failed - Manual intervention required

            Error: ${{ failure.message }}

# Configure journald for structured logs
sudo mkdir -p /etc/systemd/journald.conf.d/

cat <<EOF | sudo tee /etc/systemd/journald.conf.d/anyt.conf
[Journal]
Storage=persistent
MaxRetentionSec=7day
MaxFileSec=1day
ForwardToSyslog=no
EOF

sudo systemctl restart systemd-journald

# promtail-config.yaml
server:
  http_listen_port: 9080

positions:
  filename: /var/lib/promtail/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: anyt-worker
    journal:
      max_age: 12h
      labels:
        job: anyt-worker
    relabel_configs:
      - source_labels: ['__journal__systemd_unit']
        target_label: 'unit'
      - source_labels: ['__journal__hostname']
        target_label: 'host'

#!/bin/bash
# Collect worker metrics for monitoring

# Get worker status
WORKER_STATUS=$(systemctl is-active anyt-worker-prod)

# Get recent attempts count
ATTEMPTS_TODAY=$(anyt attempt list --since "1 day ago" | wc -l)

# Get success/failure rate
SUCCESS_COUNT=$(journalctl -u anyt-worker-prod --since "1 day ago" | grep "completed and marked as done" | wc -l)
FAILURE_COUNT=$(journalctl -u anyt-worker-prod --since "1 day ago" | grep "Failed to" | wc -l)

# Output metrics (Prometheus format)
cat <<EOF
# HELP anyt_worker_up Worker service status
# TYPE anyt_worker_up gauge
anyt_worker_up{environment="production"} $( [ "$WORKER_STATUS" = "active" ] && echo 1 || echo 0 )

# HELP anyt_attempts_total Total attempts in last 24h
# TYPE anyt_attempts_total counter
anyt_attempts_total{environment="production"} $ATTEMPTS_TODAY

# HELP anyt_attempts_success_total Successful attempts in last 24h
# TYPE anyt_attempts_success_total counter
anyt_attempts_success_total{environment="production"} $SUCCESS_COUNT

# HELP anyt_attempts_failure_total Failed attempts in last 24h
# TYPE anyt_attempts_failure_total counter
anyt_attempts_failure_total{environment="production"} $FAILURE_COUNT
EOF

# /etc/cron.d/anyt-metrics
*/5 * * * * anyt-worker /usr/local/bin/anyt-metrics.sh > /var/lib/node_exporter/textfile_collector/anyt.prom

#!/bin/bash
set -euo pipefail

# Check systemd service
if ! systemctl is-active --quiet anyt-worker-prod; then
    echo "ERROR: Worker service is not running"
    exit 1
fi

# Check API connectivity
if ! curl -f -s -H "X-API-Key: ${ANYT_API_KEY}" \
    "${ANYT_API_URL}/v1/health" > /dev/null; then
    echo "ERROR: Cannot reach API endpoint"
    exit 1
fi

# Check recent activity (should have polled in last 5 minutes)
LAST_POLL=$(journalctl -u anyt-worker-prod --since "5 minutes ago" | \
    grep -c "Checking for available tasks" || echo 0)

if [ "$LAST_POLL" -lt 1 ]; then
    echo "WARNING: No polling activity in last 5 minutes"
    exit 1
fi

echo "OK: Worker is healthy"
exit 0

# /etc/cron.d/anyt-health
*/5 * * * * anyt-worker /usr/local/bin/anyt-health-check.sh || \
    echo "Health check failed" | mail -s "AnyTask Worker Alert" [email protected]

#!/bin/bash
# /usr/local/bin/anyt-backup.sh

BACKUP_DIR="/var/backups/anyt/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Backup configurations
tar -czf "$BACKUP_DIR/config.tar.gz" /etc/anyt/
tar -czf "$BACKUP_DIR/workspace.tar.gz" /opt/projects/production/.anyt/

# Backup workflows
tar -czf "$BACKUP_DIR/workflows.tar.gz" /etc/anyt/workflows/

# Keep last 30 days
find /var/backups/anyt/ -type d -mtime +30 -exec rm -rf {} +

# 1. Restore from backup
cd /
sudo tar -xzf /var/backups/anyt/YYYYMMDD/config.tar.gz
sudo tar -xzf /var/backups/anyt/YYYYMMDD/workspace.tar.gz

# 2. Set correct permissions
sudo chown -R anyt-worker:anyt-worker /etc/anyt /opt/projects/production/.anyt

# 3. Restart services
sudo systemctl restart anyt-worker-prod

# 4. Verify
sudo systemctl status anyt-worker-prod
journalctl -u anyt-worker-prod -f

# Use caching for dependencies
- name: Cache Python Dependencies
  uses: anyt/cache@v1
  with:
    path: ~/.cache/uv
    key: python-${{ hashFiles('**/requirements.txt', '**/uv.lock') }}

- name: Cache Node Modules
  uses: anyt/cache@v1
  with:
    path: node_modules
    key: node-${{ hashFiles('**/package-lock.json') }}

[Service]
# Limit memory usage
MemoryMax=4G
MemoryHigh=3G

# Limit CPU usage
CPUQuota=200%

# Limit file descriptors
LimitNOFILE=65536

# Limit processes
LimitNPROC=4096