Install: pip install cptd

CPTD CLI is not just a command-line tool. It is an extensible management platform designed for:
• Creating custom commands and extensions;
• Sharing commands between users;
• Integrating with external tools and APIs;
• Automating workflows, reporting, and strategic analysis;
• Acting as the engine for any custom or graphical interface (UI).

1. CLI as an Extensible Platform
Each command is a standard Python file with a defined interface. You can create your own command in under 5 minutes.
Commands are simple Python modules with minimal structure. Each command includes a manifest file containing information (name, description, author, version, dependencies). Developers can use the cptd newcommand template to get started quickly.

Commands can be tested and debugged interactively without restarting the system:

cptd command --add yourcommand.zip     # add command (ZIP only)  
cptd command --del yourcommand         # remove command  

Run the command:

cptd yourcommand

Run the project:

cptd yourcommand

2. Security and Validation
• All commands in the public repository undergo strict security review.
• Upon installation, automatic checks are performed for prohibited code (e.g., pip install inside the command).
• When publishing to the public repository, each command is checked for security, structure, and manifest integrity.
• Community-contributed commands are moderated before publication.

3. CLI as the Engine for UI
The CLI acts as a bridge for graphical interfaces that use it as the backend. CPTD CLI serves as the backend for all current and future interfaces. All logic is processed through the CLI.

4. Centralized and Decentralized Distribution
• Commands can be downloaded and used from the public repository.
• A standard format for importing, exporting, and sharing commands is supported.

5. Autonomy and Reliability
• Fully offline operation — no cloud required.
• No telemetry, hidden data collection, or external connections.
• Supported on Windows, Linux, and macOS.

• Flexibility: Adapt the CLI to any scenario — from license checking to automation.
• Scalability: From individual developers to entire teams.
• Extensibility: Creation, sharing, moderation, and integration of commands.
• Security: Strict checks at all stages — install, execute, publish.
• Transparency: All code is open, modular, and auditable.

CPTD CLI is a free open-source project https://cptdcli.com** . The complete source code is available in the public repository:
👉 https://github.com/asbjornrasen/cptd-cli
This ensures full transparency, builds trust and security, and allows anyone to verify, modify, or copy the system. Thanks to its openness, CPTD guarantees independence and verifiability in the long term.

The following commands are available in the CPTD CLI:

⚠️ Note: The CLI is under active development and not yet ready for production use.

Submission Format (ZIP only)
All CPTD CLI commands must be submitted as a .zip archive.

Example of a Simple Command:

taskcleaner.zip
├── main.py
├── icon.png
├── manifest.yaml
└── manifest.json

Example of a Project Command with Subfolders:

taskmanager.zip
├── main.py
├── icon.png
├── manifest.yaml
├── manifest.json
├── util/
│   └── parser.py
└── service/
    └── api.py

Rules:
• main.py, icon.png, manifest.yaml, and manifest.json must be at the archive root
• The archive must not contain a nested folder named after the command
• Archive name defines the command name: taskcleaner.zip → cptd taskcleaner
• In both manifests, the entrypoint field must be main.py
• If main.py is not at the root — the command will be rejected
• Both manifest files (YAML and JSON) are required
• Subfolders like util/, service/ are allowed
• Auto-installing dependencies within the code is prohibited

1. Command Description in SYNTAX:

SYNTAX = {
  "name": "yourcommand",
  "description": "What the command does",
  "usage": "cptd yourcommand --input <path> [--flag]",
  "arguments": [
    {"name": "--input", "required": True, "help": "Path to input file"},
    {"name": "--flag", "required": False, "help": "Optional flag"}
  ],
  "examples": [
    "cptd yourcommand --input file.cptd",
    "cptd yourcommand --input folder --flag"
  ]
}

2. run(argv) Function

def run(argv):
    ...

3. Handle --help:

if "--help" in argv or "-h" in argv:
    print_help(SYNTAX)
    return

4. Print help on error:

except Exception as e:
    print(f"[!] Argument error: {e}")
    print_help(SYNTAX)
    return

5. Recommended Template:

# --- blocking launch if the system does not match the one specified in the manifest, uncomment, leave in this place. ----
# from cptd_tools.os_guard import ensure_compatible
# ensure_compatible(__file__)
# --------------------------------------------------------------------------------

import sys
from pathlib import Path
import argparse
from cptd_tools.syntax_utils import print_help

SYNTAX = {
    "name": "yourcommand",
    "description": "What the command does",
    "usage": "cptd yourcommand --input <path> [--flag]",
    "arguments": [
        {"name": "--input", "required": True, "help": "Path to input file"},
        {"name": "--flag", "required": False, "help": "Optional flag"},
        {"name": "--example", "required": False, "help": "Example mode"}
    ],
    "examples": [
        "cptd yourcommand --input file.cptd --flag",
        "cptd yourcommand --input file.cptd --example"
    ]
}

#----additional methods section----here you insert the logic of your command

def test():
    print("[test] Service started")
    print("[test] Service is running...")
    time.sleep(2)
    print("[test] Service finished running")

#---------------------------------

def run(argv):
    # Check if --help or -h is passed
    if "--help" in argv or "-h" in argv:
        print_help(SYNTAX)
        return
    # The mandatory argument "add_help=False" disables argparse help and enables cptd help
    prs = argparse.ArgumentParser("cptd yourcommand", add_help=False)

    # Adding arguments
    prs.add_argument('--input', type=Path, required=True, help='Path to input file')
    prs.add_argument('--flag', action='store_true', help='Optional flag')
    prs.add_argument('--example', action='store_true', help='Optional flag')



    try:
        args = prs.parse_args(argv)
    except SystemExit:
        print("[!] Argument parsing failed.")
        print_help(SYNTAX)
        return

    # If the --input argument is passed along with a value, for example: --input value, args.input evaluates to True and takes the value ,type=Path, type=str , type=int
    if args.input:
        print(f"[✔] Path provided: {args.input}")
        test()
     
    # If the --flag argument is passed without a value, action='store_true'
    if args.flag:
        print("[✔] Flag is set")
        
    # If the --example argument is passed without a value, action='store_true'
    if args.example:
        print("[✔] Example flag is set")

# Do not specify in service files.        
if __name__ == "__main__":
    run(sys.argv[1:])

• Add: cptd command --add yourcommand.zip
• View all: cptd list
• Get help: cptd yourcommand --help
• Run command: cptd yourcommand
• Remove: cptd command --del yourcommand

• SYNTAX is required
• run(argv) is required
• Use print_help(SYNTAX) only — do not rely on argparse for help
• Code must be clean, readable, minimal dependencies

Manifests must be in the same folder as main.py:
• manifest.yaml — human-readable
• manifest.json — machine-readable

Required fields in the manifests:
• name: unique name of the command (must match the archive name)
• description: a description of the command
• version: for example, 1.0.0
• entrypoint: always main.py
• target: supported operating systems (all, linux, windows, macos)
• dependencies: list of required pip dependencies
• author: name of the author
• email: contact email
• github: link to the GitHub repository
• website: website (optional)
• license: license (e.g., MIT, license.md, etc.)

Name: cpdsl
Role: Interpreter for .dsl scripts that sequentially execute installed cptd commands
Support: Cross-platform (Linux / Windows / Mac)
Format: YAML step definitions

cpdsl is the official script interpreter of CPTD CLI. It executes YAML-defined commands line-by-line — turning manual sequences into structured, repeatable, and safe automation.

• Automate routine processes with cptd commands
• Replace fragile shell scripts with validated YAML instructions
• Portability — one .dsl file can run anywhere
• Transparent, repeatable, logged steps
• Centralizes complex workflows: backup, encryption, upload, logging, etc.

• A single .dsl file defines a full workflow
• Scenarios can be shared as modules
• UI integration: e.g., "Run Backup" button
• Debug and reuse scenarios easily

cptd cpdsl run backup.dsl --log out.txt --strict --wait-all --summary

name: "Script Name"
description: "Short purpose description"

steps:
  - name: "Step Name"
    command: "command_name"
    args:
      --flag1: value
      --flag2: true
    async: true
    depends_on: "step_name"

Top-Level:

Inside steps[]:

Environment Variables:

args:
  --password-env: SFTP_PASS

→ Becomes: --password-env <value from SFTP_PASS>

name: "Backup"
description: "Mount, archive and upload data"

steps:
  - name: "Mount"
    command: "cpdisk"
    args:
      --mount: true
      --file: "vault.hc"

  - name: "Archive"
    command: "compress"
    args:
      --input: "/vault/data"
      --output: "/tmp/data.zip"
    depends_on: "Mount"

  - name: "Upload"
    command: "uploader"
    args:
      --file: "/tmp/data.zip"
      --target: "sftp://host/upload"
      --password-env: SFTP_PASS
    async: true
    depends_on: "Archive"

cptd cpdsl run backup.dsl --log log.txt --strict --wait-all --summary

Arguments:

Sample Summary Table:

Summary:
✔ Step 1 - Mount                [OK]
✔ Step 2 - Archive              [OK]
✔ Step 3 - Upload               [ASYNC]

• Always provide unique name: for each step
• Use depends_on to define logical sequence
• Use async: true for background tasks
• Store .dsl files in scripts/ or scenarios/ folders

cpdsl is not just syntax. It's structure. It's automation strategy.
Forget the chaos of bash chains and &&.
Create readable, repeatable, testable scenarios that evolve with your project.

1. Fork: https://github.com/asbjornrasen/cptdcli-plugin

2. Create branch: feature/mycommand

3. Add ZIP: community_plugin/your_system/your_command.zip

your_system:

linux/ — plugins designed for Linux OS.

macos/ — plugins compatible with macOS.

windows/ — plugins implemented for Windows.

4. Make sure:

   • Structure is valid

   • main.py, manifests at root

   • --help works

   • No auto-installation logic

5. Add manifest to community-plugins.json:

{
  "name": "example",
  "description": "example",
  "long_description": "example",
  "version": "1.0.0",
  "target": "Windows",
  "entrypoint": "example.py",
  "dependencies": ["example"],
  "author": "example",
  "email": "example@example.com",
  "github": "https://github.com/example/example",
  "website": "https://example.com",
  "license": "example.md",
  "documentation":""
}

6. Submit Pull Request with description

Tip: Follow CPTD philosophy — clarity, modularity, practicality.

Need a template?

cptd newcommand

You'll get a project structure with main.py, manifest.yaml, util/, service/.

Ready to create commands? CPTD CLI awaits your ideas.
The best ones will be included in the official release.

Summary:
CPTD CLI is more than a tool. It’s a foundation for creating, testing, and sharing smart utilities.
Its flexible architecture, strict security, and open model make it an ideal management core for both personal and enterprise systems.