@lizard-build/cli 0.1.0 → 0.3.30

package/.github/workflows/release.yml

@@ -0,0 +1,90 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write  # required for npm OIDC Trusted Publisher
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Bump patch version
+        id: bump
+        run: |
+          CURRENT=$(node -p "require('./package.json').version")
+          IFS='.' read -r MAJ MIN PAT <<< "$CURRENT"
+          NEW="$MAJ.$MIN.$((PAT + 1))"
+          echo "version=$NEW" >> $GITHUB_OUTPUT
+
+          node -e "
+            const fs = require('fs');
+            const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+            pkg.version = '$NEW';
+            fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+          "
+          sed -i "s/export const CURRENT_VERSION = \".*\"/export const CURRENT_VERSION = \"$NEW\"/" src/lib/updater.ts
+
+          git add package.json src/lib/updater.ts
+          git commit -m "chore: bump version to v$NEW [skip ci]"
+          git tag "v$NEW"
+          git push origin main --tags
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Upgrade npm
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies (bun)
+        run: bun install
+
+      - name: Build binaries
+        run: |
+          mkdir -p bin
+          bun build --compile --target=bun-darwin-arm64  src/index.ts --outfile bin/lizard-darwin-arm64
+          bun build --compile --target=bun-darwin-x64    src/index.ts --outfile bin/lizard-darwin-x64
+          bun build --compile --target=bun-linux-x64     src/index.ts --outfile bin/lizard-linux-x64
+          bun build --compile --target=bun-linux-arm64   src/index.ts --outfile bin/lizard-linux-arm64
+          bun build --compile --target=bun-windows-x64   src/index.ts --outfile bin/lizard-windows-x64.exe
+
+      - name: Create GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ steps.bump.outputs.version }}
+          name: v${{ steps.bump.outputs.version }}
+          files: |
+            bin/lizard-darwin-arm64
+            bin/lizard-darwin-x64
+            bin/lizard-linux-x64
+            bin/lizard-linux-arm64
+            bin/lizard-windows-x64.exe
+          generate_release_notes: true

package/AGENTS.md

@@ -0,0 +1,113 @@
+# AGENTS.md
+
+Instructions for AI coding agents working in this repo (`@lizard-build/cli`).
+
+## Package manager
+
+This project uses **npm**. Don't introduce pnpm/yarn lockfiles. Scripts:
+
+- `npm run build` — TypeScript compile to `dist/`
+- `npm run dev` — run from source via `tsx`
+- `npm test` — integration tests (`test/cli.test.ts`)
+- `npm run test:unit` — unit tests (`test/unit/*`)
+
+The published `bin` is `dist/index.js`. Always run `npm run build` before testing against `dist/`.
+
+## Project layout
+
+```
+src/
+  index.ts          # Commander root, banner, preAction (auth + JSON mode), --help --json dump
+  commands/<name>.ts  # one file per top-level command; exports register<Name>(program)
+  lib/
+    api.ts          # fetch wrapper, APIError
+    auth.ts         # token store, requireAuth()
+    config.ts       # ~/.lizard/config.json read/write
+    format.ts       # printJSON, isJSONMode, success/error/info/warn, table, statusColor
+    picker.ts       # interactive @clack pickers
+    resolve.ts      # resolve workspace/project/service from flags or linked dir
+    updater.ts      # self-update (precompiled binary only — see note below)
+skill-data/<name>/SKILL.md   # agent skills served by `lizard skill get <name>`
+dist/               # tsc output, committed; this is what npm ships
+test/cli.test.ts    # integration tests (spawn the CLI)
+test/unit/*.test.ts # unit tests
+```
+
+## Code style
+
+- Kebab-case for CLI flags (`--service-name`, never `--serviceName`).
+- No emojis in code, output, or docs. Unicode glyphs (`✓`, `✗`, `→`) via `chalk` are fine.
+- Colors: use `chalk` and `lib/format.ts` helpers. Never hardcode ANSI escapes.
+- `info`/`success`/`warn`/`error` write to **stderr**; payload (`printJSON`, table rows) goes to **stdout**. Pipes (`| jq`, `> file`) must work.
+- Strict TypeScript. No `any` in new code unless interacting with `commander`'s loose types.
+
+## JSON mode is required
+
+Every user-facing command must support `--json`. The harness in `src/index.ts` auto-enables it when stdout isn't a TTY, and `lib/format.ts` gates pretty prints. Pattern:
+
+```ts
+if (isJSONMode()) {
+  printJSON({ /* machine-readable */ });
+  return;
+}
+// human-readable output
+table(...); info(...);
+```
+
+For streaming commands (`up`, `logs`), JSON mode emits **one event per line**:
+`{ event: "log", line }`, terminating with `{ event: "done" }` or `{ event: "error", message }`. See `commands/logs.ts` and `commands/up.ts` for shape.
+
+## Adding a command
+
+1. Create `src/commands/<name>.ts` exporting `register<Name>(program: Command)`.
+2. Import + call in `src/index.ts` (alphabetical, both the import and the `register…(program)` line).
+3. If it shouldn't require login, add its top-level name to the `noAuth` set in `src/index.ts`. The walk-up matches subcommands automatically.
+4. Update **`skill-data/core/SKILL.md`** so the agent skill teaches the new flag/command. The CLI serves it via `lizard skill get core`, so users see the matching version regardless of when the skill was installed.
+5. Add tests in `test/unit/<name>.test.ts` (or extend `test/cli.test.ts` for integration).
+6. `--help --json` is autogenerated by the dumper in `src/index.ts` — no extra wiring needed, but verify the new flags/args show up correctly.
+
+## Skill content (`skill-data/`)
+
+This directory holds the canonical agent skill markdown. The public discovery stub lives in [`lizard-build/lizard-skills`](https://github.com/lizard-build/lizard-skills) and is intentionally thin — it just tells agents to run `lizard skill get <name>` to fetch the version-matched content from the installed CLI.
+
+When you change platform behavior (build pipeline, env precedence, addon env vars, deploy flow), update `skill-data/core/SKILL.md`. Do **not** put that content in the lizard-skills stub — it would go stale.
+
+Frontmatter format (YAML):
+```yaml
+---
+name: <slug>
+description: "<trigger-rich one-liner>"
+argument-hint: "[optional natural-language request]"
+allowed-tools: Bash(lizard:*)
+---
+```
+
+## Auth handling
+
+`requireAuth()` runs automatically in `preAction` for any command not in the `noAuth` set. It auto-triggers the login flow when no token is on disk. Don't call `requireAuth()` manually inside command actions.
+
+## Exit codes
+
+Defined in `src/index.ts`:
+- `0` success
+- `1` generic error
+- `2` auth (401/403)
+- `3` not found (404)
+- `4` timeout (408/504)
+- `5` cancelled by user
+
+Throw `APIError` (from `lib/api.ts`) with a `status` so the root catch maps it correctly. Don't `process.exit()` from inside command actions — let errors propagate.
+
+## Releases / versioning
+
+Version lives in `package.json` AND `src/lib/updater.ts` (`CURRENT_VERSION`). Bumping one without the other breaks self-update reporting. Commit messages for bumps: `chore: bump version to vX.Y.Z [skip ci]`.
+
+## Known landmine: `updater.ts`
+
+`selfUpdate()` calls `renameSync(downloadedBinary, process.execPath)`. This works for the precompiled standalone install (`~/.lizard/bin/lizard`) where `process.execPath` IS the lizard binary. For npm installs, `process.execPath` is `node` and self-update will overwrite the user's node interpreter. Guard before adding new self-update code paths; for npm users, prefer instructing `npm i -g @lizard-build/cli@latest`.
+
+## Tests
+
+Unit tests are vitest, fast, and can be run while iterating. The integration suite (`npm test`) spawns the built CLI from `dist/` against fixtures in `test/fixtures/`, so re-run `npm run build` first.
+
+Two pre-existing failures in `test/unit/json.test.ts` reference a `lizard list` command that was dropped in commit `1c856f9` — not blocking; the fixture list there needs to be updated separately.

package/README.md

@@ -0,0 +1,41 @@
+# Lizard CLI
+
+Deploy and manage apps on [Lizard](https://lizard.build).
+
+## Install
+
+```bash
+curl -fsSL https://lizard.build/install.sh | bash
+```
+
+Or via npm:
+
+```bash
+npm i -g @lizard-build/cli
+```
+
+## Usage
+
+```bash
+lizard login
+lizard init
+lizard up
+```
+
+## Common commands
+
+```
+lizard up         # upload and deploy code
+lizard logs       # stream runtime logs
+lizard ps         # list services
+lizard add        # add a database or service
+lizard secrets    # manage secrets
+lizard scale      # scale replicas / CPU / memory
+lizard domain     # manage domains
+```
+
+Run `lizard --help` for the full list.
+
+## License
+
+MIT

package/dist/commands/add.js

@@ -1,24 +1,154 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
+import { api, withQuery, withScope } from "../lib/api.js";
+import { getProjectLink, updateProjectLink, DEFAULT_REGION } from "../lib/config.js";
+import { scopeForProject } from "../lib/resolve.js";
+import { resolveWorkspace } from "../lib/picker.js";
 import { success, info, isJSONMode, printJSON, isTTY, table, } from "../lib/format.js";
+import { validateName, addonRefName } from "../lib/name.js";
 const CATALOG = [
     { name: "postgres", label: "PostgreSQL", description: "Relational database" },
     { name: "redis", label: "Redis", description: "In-memory key-value store" },
-    { name: "mysql", label: "MySQL", description: "Relational database" },
-    { name: "mongodb", label: "MongoDB", description: "Document database" },
+    { name: "s3", label: "S3 Bucket", description: "S3-compatible object storage" },
 ];
+async function detectPortFromDockerfile(repo) {
+    const repoPath = repo.startsWith("http") ? repo.replace(/^https?:\/\/github\.com\//, "") : repo;
+    for (const branch of ["main", "master"]) {
+        try {
+            const res = await fetch(`https://raw.githubusercontent.com/${repoPath}/${branch}/Dockerfile`, { signal: AbortSignal.timeout(5000) });
+            if (!res.ok)
+                continue;
+            const text = await res.text();
+            const match = text.match(/^EXPOSE\s+(\d+)/m);
+            if (match)
+                return parseInt(match[1], 10);
+        }
+        catch { }
+    }
+    return undefined;
+}
+/** Most-useful env var to surface as a reference example for each addon type.
+ *  Mirrors urlKey in lizard-client/src/components/AddonPanel.tsx. */
+function addonExampleVar(type) {
+    switch (type) {
+        case "postgres":
+        case "mysql":
+            return "DATABASE_URL";
+        case "mongo":
+            return "MONGODB_URL";
+        case "redis":
+            return "REDIS_URL";
+        case "s3":
+            return "S3_ENDPOINT";
+        default:
+            return "KEY";
+    }
+}
+function normalizeDbName(name) {
+    for (const c of CATALOG) {
+        if (c.name === name)
+            return c.name;
+        if (c.aliases?.includes(name))
+            return c.name;
+    }
+    return name;
+}
+/**
+ * Resolve a project by name/slug/id. Name-based lookup hits /api/projects and
+ * matches against the list. Falls back to the cwd-linked project when no
+ * -p/--project is supplied.
+ *
+ * When `workspaceFlag` is provided, the lookup is constrained to that
+ * workspace — useful for disambiguating identically-named projects.
+ */
+async function resolveProject(flagValue, workspaceFlag) {
+    if (flagValue) {
+        let workspaceId;
+        if (workspaceFlag) {
+            workspaceId = (await resolveWorkspace(workspaceFlag)).id;
+        }
+        const projects = await api.get(withQuery("/api/projects", { workspaceId }));
+        const matches = projects.filter((pr) => pr.id === flagValue ||
+            pr.slug === flagValue ||
+            pr.name === flagValue);
+        if (matches.length === 0) {
+            throw new Error(`Project "${flagValue}" not found. Available: ${projects.map((pr) => pr.name).join(", ") || "(none)"}`);
+        }
+        if (matches.length > 1) {
+            const detail = matches
+                .map((m) => `  • ${m.name}  in ${m.workspaceName ?? "(personal)"}`)
+                .join("\n");
+            throw new Error(`Multiple projects named "${flagValue}" found:\n${detail}\nPass --workspace to disambiguate.`);
+        }
+        return matches[0].id;
+    }
+    const link = getProjectLink();
+    if (link?.projectId)
+        return link.projectId;
+    throw new Error("No project linked to this directory. Pass -p <project-name> or run `lizard init`.");
+}
+function parseVariables(pairs) {
+    if (!pairs?.length)
+        return {};
+    const out = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf("=");
+        if (eq < 1)
+            throw new Error(`Invalid variable: "${pair}". Use KEY=value`);
+        out[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return out;
+}
 export function registerAdd(program) {
     program
         .command("add")
-        .argument("[name]", "Service name from catalog (postgres, redis, mysql, mongodb)")
-        .description("Add a service to the project")
-        .option("--list", "Show available services")
-        .option("--region <region>", "Region for the service")
-        .action(async (name, opts) => {
-        // Show catalog
-        if (opts.list || (!name && !isTTY())) {
+        .argument("[types...]", "Addon type(s) to add (postgres / redis / s3). Multiple allowed: `add postgres redis s3`")
+        .description("Add a database, service, or repo to the project")
+        .option("-a, --addon <type...>", "Add one or more managed addons (multi-add: -a postgres -a redis -a s3)")
+        .option("-s, --service <name>", "Create an empty service with this name")
+        .option("-r, --repo <repo>", "Create a service from a GitHub repo (owner/repo)")
+        .option("-v, --variables <kv>", "KEY=value pair to seed the service. Repeat for multiple: -v K1=v1 -v K2=v2. Ignored for managed addons.", (val, prev) => [...prev, val], [])
+        .option("-n, --name <name>", "Name used in ${{<name>.KEY}} templates and shown in the dashboard. Renamable; refs stay stable.")
+        .option("--instance-name <name>", "(deprecated) alias for --name")
+        .option("-w, --workspace <ws>", "Disambiguate project lookup by workspace")
+        .option("--region <code>", "Region to provision the addon/service in")
+        .option("--no-deploy", "With -r: attach repo but skip the initial build. First deploy fires on next `service set` or `redeploy`.")
+        .option("--list", "Show available database types")
+        .action(async (types, opts, command) => {
+        const merged = command.optsWithGlobals();
+        await runAdd({
+            types,
+            addon: opts.addon,
+            service: opts.service,
+            repo: opts.repo,
+            variables: opts.variables,
+            name: opts.name,
+            instanceName: opts.instanceName,
+            workspace: opts.workspace,
+            region: opts.region,
+            noDeploy: opts.deploy === false,
+            list: opts.list,
+            projectFlag: merged.project,
+        });
+    });
+}
+async function runAdd(input) {
+    const types = input.types ?? [];
+    const opts = {
+        addon: input.addon,
+        service: input.service,
+        repo: input.repo,
+        variables: input.variables,
+        name: input.name,
+        instanceName: input.instanceName,
+        list: input.list,
+    };
+    const projectFlag = input.projectFlag;
+    const workspaceFlag = input.workspace;
+    const region = input.region ?? DEFAULT_REGION;
+    {
+        // ── --list: show DB catalog and exit ──────────────────────────────
+        if (opts.list || (!types.length && !opts.addon && !opts.service && !opts.repo && !isTTY())) {
             if (isJSONMode()) {
                 printJSON(CATALOG);
             }
@@ -27,46 +157,189 @@ export function registerAdd(program) {
             }
             return;
         }
-        // Interactive selection
-        if (!name) {
-            const selected = await p.select({
-                message: "Select service to add",
-                options: CATALOG.map((c) => ({
-                    value: c.name,
-                    label: c.label,
-                    hint: c.description,
-                })),
-            });
-            if (p.isCancel(selected))
-                process.exit(5);
-            name = selected;
+        const variables = parseVariables(opts.variables);
+        if (opts.instanceName && !opts.name) {
+            info(chalk.yellow("Warning: --instance-name is deprecated, use --name instead."));
+            opts.name = opts.instanceName;
         }
-        // Validate name is in catalog
-        const catalogEntry = CATALOG.find((c) => c.name === name);
-        if (!catalogEntry) {
-            throw new Error(`Unknown service "${name}". Available: ${CATALOG.map((c) => c.name).join(", ")}`);
+        if (opts.name) {
+            const err = validateName(opts.name);
+            if (err)
+                throw new Error(`Invalid --name: ${err}`);
         }
-        const projectId = resolveProjectId(program.opts().project);
-        const region = opts.region || program.opts().region;
-        info(`Adding ${chalk.cyan(catalogEntry.label)}...`);
-        const addon = await api.post(`/api/projects/${projectId}/addons`, {
-            addonType: name,
-            region,
-        });
-        if (isJSONMode()) {
-            printJSON(addon);
+        // Resolve project up front so we fail before any wizard prompts or
+        // API calls instead of after the user has filled out the wizard.
+        const projectId = await resolveProject(projectFlag, workspaceFlag);
+        const scope = await scopeForProject(projectId);
+        // ── positional <types...> and/or -a <type...> ────────────────────
+        const databases = [];
+        const candidates = [...(opts.addon ?? []), ...types];
+        for (const t of candidates) {
+            const norm = normalizeDbName(t);
+            if (!CATALOG.some((c) => c.name === norm)) {
+                throw new Error(`Unknown addon "${t}". Available: ${CATALOG.map((c) => c.name).join(", ")}`);
+            }
+            databases.push(norm);
+        }
+        // Nudge users off the verbose single-arg `-a` form toward `lizard add <type>`.
+        if (opts.addon?.length === 1 && !types.length && !isJSONMode()) {
+            info(chalk.dim(`Tip: shorter form — \`lizard add ${opts.addon[0]}\``));
+        }
+        if (databases.length > 0) {
+            if (opts.variables?.length) {
+                info(chalk.yellow("Warning: --variables is ignored for managed addons"));
+            }
+            const isSingle = databases.length === 1;
+            for (const db of databases) {
+                const cat = CATALOG.find((c) => c.name === db);
+                info(`Adding ${chalk.cyan(cat.label)}...`);
+                const addon = await api.post(withScope(`/api/projects/${projectId}/addons`, scope), {
+                    type: db,
+                    region,
+                    ...(opts.name ? { name: opts.name } : {}),
+                });
+                if (isJSONMode())
+                    printJSON(addon);
+                else {
+                    success(`${cat.label} added`);
+                    const ref = addonRefName({ name: addon.name, type: addon.type, addonType: addon.addonType });
+                    const exampleVar = addonExampleVar(db);
+                    if (ref)
+                        info(`  Name: ${chalk.bold(ref)}`);
+                    if (ref) {
+                        info("");
+                        info(chalk.dim(`  Reference the ${exampleVar} from other services:`));
+                        info(`    ${chalk.cyan(`\${{${ref}.${exampleVar}}}`)}`);
+                    }
+                }
+                if (isSingle) {
+                    try {
+                        updateProjectLink({ serviceId: addon.id, serviceName: addon.name });
+                    }
+                    catch { }
+                }
+            }
             return;
         }
-        success(`${catalogEntry.label} added`);
-        if (addon.hostname) {
-            info(`  Host: ${chalk.cyan(addon.hostname)}`);
+        // ── -r <repo> ─────────────────────────────────────────────────────
+        if (opts.repo) {
+            const serviceName = opts.name || opts.service || opts.repo.split("/").pop() || "service";
+            info(`Creating service ${chalk.bold(serviceName)} from ${chalk.cyan(opts.repo)}...`);
+            const detectedPort = await detectPortFromDockerfile(opts.repo);
+            if (detectedPort)
+                info(`Detected port ${chalk.bold(detectedPort)} from Dockerfile`);
+            const app = await api.post(withScope(`/api/projects/${projectId}/apps`, scope), {
+                name: serviceName,
+                repoUrl: opts.repo.startsWith("http")
+                    ? opts.repo
+                    : `https://github.com/${opts.repo}`,
+                region,
+                variables,
+                ...(detectedPort ? { containerPort: detectedPort } : {}),
+                ...(input.noDeploy ? { skipInitialDeploy: true } : {}),
+            });
+            if (isJSONMode())
+                printJSON(app);
+            else {
+                success(`Service ${chalk.bold(app.name)} created${input.noDeploy ? " (initial deploy deferred)" : ""}`);
+                info("");
+                if (input.noDeploy) {
+                    info(chalk.dim(`  Configure and trigger the first deploy:`));
+                    info(`    ${chalk.cyan(`lizard service set ${app.name} --set buildCommand='...' --set startCommand='...'`)}`);
+                    info("");
+                }
+                info(chalk.dim(`  Reference this service's private URL from other services:`));
+                info(`    ${chalk.cyan(`\${{${app.name}.LIZARD_PRIVATE_DOMAIN}}`)}`);
+            }
+            try {
+                updateProjectLink({ serviceId: app.id, serviceName: app.name });
+            }
+            catch { }
+            return;
+        }
+        // ── --service <name> (empty service) ──────────────────────────────
+        if (opts.service) {
+            info(`Creating empty service ${chalk.bold(opts.service)}...`);
+            const app = await api.post(withScope(`/api/projects/${projectId}/apps`, scope), {
+                name: opts.service,
+                region,
+                variables,
+            });
+            if (isJSONMode())
+                printJSON(app);
+            else {
+                success(`Service ${chalk.bold(app.name)} created`);
+                info("");
+                info(chalk.dim(`  Reference this service's private URL from other services:`));
+                info(`    ${chalk.cyan(`\${{${app.name}.LIZARD_PRIVATE_DOMAIN}}`)}`);
+            }
+            try {
+                updateProjectLink({ serviceId: app.id, serviceName: app.name });
+            }
+            catch { }
+            return;
         }
-        if (addon.envVars) {
-            info(chalk.dim("\n  Environment variables added to project:"));
-            for (const [key, val] of Object.entries(addon.envVars)) {
-                info(`  ${chalk.bold(key)}=${chalk.dim(val)}`);
+        // ── No flags + no positional → interactive wizard ────────────────
+        // After the wizard collects a concrete choice we re-enter runAdd
+        // directly (no program.parseAsync round-trip): runAdd routes to a
+        // concrete branch above based on the inputs we hand it.
+        if (!types.length && !input.skipWizard && isTTY()) {
+            const kind = await p.select({
+                message: "What do you need?",
+                options: [
+                    { value: "database", label: "Database", hint: "postgres / redis" },
+                    { value: "s3", label: "S3 Bucket", hint: "S3-compatible object storage" },
+                    { value: "repo", label: "GitHub Repo", hint: "create a service from a repo" },
+                    { value: "service", label: "Empty Service", hint: "create a service to upload code into" },
+                ],
+            });
+            if (p.isCancel(kind))
+                process.exit(5);
+            if (kind === "database") {
+                const sel = await p.select({
+                    message: "Select database",
+                    options: CATALOG.filter((c) => c.name !== "s3").map((c) => ({
+                        value: c.name,
+                        label: c.label,
+                        hint: c.description,
+                    })),
+                });
+                if (p.isCancel(sel))
+                    process.exit(5);
+                await runAdd({ ...input, types: [sel], skipWizard: true });
+                return;
+            }
+            if (kind === "s3") {
+                await runAdd({ ...input, types: ["s3"], skipWizard: true });
+                return;
+            }
+            if (kind === "repo") {
+                const repo = await p.text({ message: "Repo (owner/name)" });
+                if (p.isCancel(repo))
+                    process.exit(5);
+                const svc = await p.text({ message: "Service name", placeholder: String(repo).split("/").pop() });
+                if (p.isCancel(svc))
+                    process.exit(5);
+                await runAdd({
+                    ...input,
+                    repo: String(repo),
+                    service: String(svc) || undefined,
+                    skipWizard: true,
+                });
+                return;
+            }
+            if (kind === "service") {
+                const svc = await p.text({ message: "Service name" });
+                if (p.isCancel(svc))
+                    process.exit(5);
+                await runAdd({ ...input, service: String(svc), skipWizard: true });
+                return;
             }
         }
-    });
+        throw new Error("No service type specified. Examples:\n" +
+            "  lizard add postgres        Add a managed database\n" +
+            "  lizard add -r owner/repo   Create a service from a GitHub repo\n" +
+            "  lizard add -s my-service   Empty service");
+    }
 }
 //# sourceMappingURL=add.js.map