Introducing cli.do: Why Your Next CLI Should Be an API

Command-line interfaces (CLIs) are the unsung heroes of the developer world. They are powerful, fast, and form the backbone of everything from Git commands to complex cloud deployments. But let's be honest: building, distributing, and maintaining them can be a tedious chore. The boilerplate, argument parsing, versioning conflicts, and distribution headaches often overshadow the core logic you actually want to ship.

What if you could bypass all that friction? What if creating a secure, scalable, and instantly shareable CLI was as simple as defining an API endpoint?

That's the paradigm shift we're introducing with cli.do—a service that lets you build and deploy command-line interfaces the agentic way. It's time to stop thinking about CLIs as local binaries and start treating them as what they truly are: powerful APIs for your terminal.

The Old Way: A Cycle of Boilerplate and Friction

For years, building a CLI has followed a familiar, often frustrating, pattern:

1. Choose a Library: You start by picking a framework like argparse, yargs, click, or cobra.
2. Write Boilerplate: You spend hours writing code to define commands, sub-commands, flags, and help text. This is purely structural code that has nothing to do with your actual business logic.
3. Handle Distribution: How do you get it to your team? Homebrew? npm? Compiling binaries for every OS? Each choice comes with its own maintenance overhead.
4. Manage Updates: You found a bug or added a feature. Now you have to push a new version and ensure everyone on the team updates their local copy.
5. Tackle Security: How do you manage access? You either roll your own authentication or face a complex integration project.

This cycle distracts from the real goal: empowering users to execute a specific piece of business logic.

The New Paradigm: Building CLIs The Agentic Way

cli.do flips the model on its head. Instead of building a distributable program, you define a command as an agentic workflow that lives on the cloud. We provide the do command, and your logic becomes instantly accessible through it.

Think of it as CLI as an API. You define the endpoint (your command name), the payload (your arguments), and the handler function (your business logic). We handle everything else.

From Code to Command in 60 Seconds

With cli.do, you don't write boilerplate; you write functionality. Here’s how you can create a robust deployment command in just a few lines of TypeScript.

import { Agent } from '@do-sdk/agent';

// Define your CLI command as an Agent
const cli = new Agent('cli.do');

// Create a 'deploy' command with project and environment arguments
cli.on('deploy', {
  project: { type: 'string', required: true },
  env: { type: 'string', default: 'staging' },
}, async (args) => {
  console.log(`Deploying ${args.project} to ${args.env}...`);
  // Your deployment logic here
  // await triggerDeployment(args.project, args.env);
  return { status: 'success', message: `Deployment of ${args.project} to ${args.env} initiated.` };
});

// Your CLI is now live and callable:
// > do cli deploy --project my-app --env production

Notice what’s missing?

• No manual argument parsing: The schema object { project: ..., env: ... } automatically generates --project and --env flags, handles types, and sets defaults.
• No help text generation: It's created for you based on your definition.
• No deployment script: The moment you write the code, the command is live and callable by anyone with permission.
• No local execution: The logic runs on our scalable infrastructure, not the user's machine.

Turn Any Workflow into a Powerful Command

The power of cli.do extends far beyond simple deployment scripts. It's a platform for turning any piece of your operation into an accessible, auditable, and secure command-line tool. This is "Business as Code" in its most practical form.

Imagine your teams running commands like:

• Data Analysis: do report generate --name quarterly_sales --format pdf
• Customer Support: do user reset-password --email user@example.com
• DevOps & SRE: do db backup --database customers --target s3-archive
• Financial Ops: do invoice process --customer-id 12345

Each command triggers a powerful, server-side agentic workflow, but for the end-user, it's just a simple, intuitive command.

Why Your Next CLI Should Be an API

By embracing the CLI-as-an-API model with cli.do, you gain immediate, transformative benefits:

• Instant Deployment & Distribution: Ship and update tools for your entire organization in seconds. No more "please update your client" messages.
• Centralized Management: A single source of truth for all your internal tools. Control access, view usage, and manage versions from one place.
• Built-in Security: Leverage the .do platform's robust authentication and authorization system to control who can run what, from internal teams to specific users.
• Effortless Scalability: Your simple script can evolve into a complex agentic workflow that orchestrates multiple services, without you ever worrying about the underlying infrastructure.
• Focus on What Matters: Stop wrestling with CLI libraries and distribution channels. Spend your time writing the business logic that delivers real value.

Ready to stop building CLIs the old way? Transform your complex business logic into intuitive, shareable command-line interfaces.

Get started with cli.do today and build your first CLI the agentic way.