skillett 0.1.0

package/dist/commands/seed.js

@@ -0,0 +1,253 @@
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { resolve, join, basename } from "node:path";
+import chalk from "chalk";
+import ora from "ora";
+import pg from "pg";
+const { Client } = pg;
+export async function seed(skillDir, opts) {
+    const resolvedDir = resolve(skillDir);
+    // Validate skill folder
+    const skillMdPath = join(resolvedDir, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        console.log(chalk.red(`Not a skill folder: ${resolvedDir}`));
+        console.log(chalk.gray("Expected SKILL.md at the root of the folder"));
+        process.exit(1);
+    }
+    // Extract integration slug and version from SKILL.md frontmatter
+    const folderName = basename(resolvedDir);
+    const slug = folderName.replace(/^skillett-/, "");
+    const skillMdContent = readFileSync(skillMdPath, "utf8");
+    const skillFm = parseFrontmatter(skillMdContent.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "");
+    const version = skillFm.version || "1.0.0";
+    // Find all endpoint markdown files
+    const endpointsDir = join(resolvedDir, "endpoints");
+    if (!existsSync(endpointsDir)) {
+        console.log(chalk.red(`No endpoints/ directory found in ${resolvedDir}`));
+        process.exit(1);
+    }
+    const endpoints = scanEndpoints(endpointsDir);
+    if (endpoints.length === 0) {
+        console.log(chalk.red("No endpoint files found with valid frontmatter"));
+        process.exit(1);
+    }
+    // Resolve env vars
+    const serverEnv = loadServerEnv();
+    const databaseUrl = opts.databaseUrl ?? process.env.DATABASE_URL ?? serverEnv.DATABASE_URL;
+    if (!databaseUrl) {
+        console.log(chalk.red("No DATABASE_URL found in server/.env"));
+        process.exit(1);
+    }
+    // Scan all markdown files for skill_files table
+    const skillFiles = scanAllFiles(resolvedDir);
+    // Step 1: Upsert skill, routes, and skill_files
+    const sql = buildSql(slug, version, endpoints, skillFiles);
+    const spinner = ora(`Seeding ${chalk.bold(String(endpoints.length))} routes + ${chalk.bold(String(skillFiles.length))} files for ${chalk.bold(slug)}…`).start();
+    const client = new Client({ connectionString: databaseUrl });
+    try {
+        await client.connect();
+        await client.query(sql);
+        spinner.succeed(`Seeded ${chalk.bold(String(endpoints.length))} routes + ${chalk.bold(String(skillFiles.length))} files for ${chalk.bold(slug)}`);
+    }
+    catch (err) {
+        spinner.fail("Seed failed");
+        const pgErr = err;
+        console.error(chalk.red(pgErr.message));
+        if (pgErr.detail)
+            console.error(chalk.gray(`Detail: ${pgErr.detail}`));
+        if (pgErr.hint)
+            console.error(chalk.gray(`Hint: ${pgErr.hint}`));
+        process.exit(1);
+    }
+    finally {
+        await client.end();
+    }
+}
+/**
+ * Recursively scan endpoints/ for .md files with frontmatter.
+ */
+function scanEndpoints(endpointsDir) {
+    const endpoints = [];
+    for (const category of readdirSync(endpointsDir)) {
+        const categoryPath = join(endpointsDir, category);
+        if (!statSync(categoryPath).isDirectory())
+            continue;
+        for (const file of readdirSync(categoryPath)) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = join(categoryPath, file);
+            const content = readFileSync(filePath, "utf8");
+            const parsed = parseEndpointFile(content, file, category);
+            if (parsed) {
+                endpoints.push(parsed);
+            }
+            else {
+                console.log(chalk.yellow(`  ⚠ Skipping ${category}/${file} — no valid frontmatter`));
+            }
+        }
+    }
+    return endpoints;
+}
+/**
+ * Parse an endpoint markdown file: extract frontmatter.
+ */
+function parseEndpointFile(content, filename, category) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch)
+        return null;
+    const fm = parseFrontmatter(fmMatch[1]);
+    if (!fm.method || !fm.path)
+        return null;
+    const name = basename(filename, ".md");
+    // Extract description from first line after the heading
+    const afterFrontmatter = content.slice(fmMatch[0].length).trim();
+    const lines = afterFrontmatter.split("\n");
+    let description = "";
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#"))
+            continue;
+        if (trimmed === "")
+            continue;
+        if (trimmed.startsWith("**Execute:**"))
+            continue;
+        if (trimmed.startsWith("|") || trimmed.startsWith("##"))
+            break;
+        description = trimmed;
+        break;
+    }
+    return {
+        name,
+        category,
+        description,
+        endpoint_config: {
+            method: fm.method,
+            base_url: fm.base_url || "https://api.github.com",
+            path: fm.path,
+            param_mapping: fm.param_mapping || {},
+        },
+    };
+}
+/**
+ * Simple YAML frontmatter parser (handles our known structure).
+ */
+function parseFrontmatter(raw) {
+    const result = {};
+    const paramMapping = {};
+    let inParamMapping = false;
+    for (const line of raw.split("\n")) {
+        if (line.match(/^param_mapping:\s*\{\}\s*$/)) {
+            result.param_mapping = {};
+            continue;
+        }
+        if (line.match(/^param_mapping:\s*$/)) {
+            inParamMapping = true;
+            continue;
+        }
+        if (inParamMapping) {
+            const mapMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+            if (mapMatch) {
+                paramMapping[mapMatch[1]] = mapMatch[2].trim();
+                continue;
+            }
+            else {
+                inParamMapping = false;
+                result.param_mapping = paramMapping;
+            }
+        }
+        const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+        if (kvMatch) {
+            result[kvMatch[1]] = kvMatch[2].trim();
+        }
+    }
+    if (inParamMapping) {
+        result.param_mapping = paramMapping;
+    }
+    return result;
+}
+/**
+ * Recursively scan all files in the skill directory for skill_files table.
+ */
+function scanAllFiles(skillDir, basePath = "") {
+    const files = [];
+    for (const entry of readdirSync(skillDir)) {
+        const fullPath = join(skillDir, entry);
+        const relativePath = basePath ? `${basePath}/${entry}` : entry;
+        if (statSync(fullPath).isDirectory()) {
+            files.push(...scanAllFiles(fullPath, relativePath));
+        }
+        else if (entry.endsWith(".md")) {
+            files.push({
+                file_path: relativePath,
+                content: readFileSync(fullPath, "utf8"),
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Build the full SQL for upserting skill, routes, and skill_files.
+ */
+function buildSql(slug, version, endpoints, skillFiles) {
+    const statements = [];
+    // Upsert into skills table
+    statements.push(`INSERT INTO skills (name, slug, latest_version)
+VALUES ('${capitalize(slug)}', '${slug}', '${version}')
+ON CONFLICT (slug) DO UPDATE SET latest_version = EXCLUDED.latest_version;`);
+    // Ensure integration exists and link to skill
+    statements.push(`INSERT INTO integrations (name, slug, auth_type, status, skill_id)
+VALUES ('${capitalize(slug)}', '${slug}', 'oauth2', 'active',
+  (SELECT id FROM skills WHERE slug = '${slug}'))
+ON CONFLICT (slug) DO UPDATE SET
+  skill_id = EXCLUDED.skill_id;`);
+    // Upsert routes
+    for (const ep of endpoints) {
+        const paramMapping = JSON.stringify(ep.endpoint_config.param_mapping).replace(/'/g, "''");
+        statements.push(`INSERT INTO routes (integration_id, name, method, base_url, path, param_mapping, category)
+VALUES (
+  (SELECT id FROM integrations WHERE slug = '${slug}'),
+  '${ep.name}',
+  '${ep.endpoint_config.method}',
+  '${ep.endpoint_config.base_url}',
+  '${ep.endpoint_config.path}',
+  '${paramMapping}'::jsonb,
+  '${ep.category}'
+)
+ON CONFLICT (integration_id, name) DO UPDATE SET
+  method = EXCLUDED.method,
+  base_url = EXCLUDED.base_url,
+  path = EXCLUDED.path,
+  param_mapping = EXCLUDED.param_mapping,
+  category = EXCLUDED.category;`);
+    }
+    // Upsert skill_files
+    for (const sf of skillFiles) {
+        const escapedContent = sf.content.replace(/'/g, "''");
+        const escapedPath = sf.file_path.replace(/'/g, "''");
+        statements.push(`INSERT INTO skill_files (skill_id, file_path, content)
+VALUES (
+  (SELECT id FROM skills WHERE slug = '${slug}'),
+  '${escapedPath}',
+  '${escapedContent}'
+)
+ON CONFLICT (skill_id, file_path) DO UPDATE SET
+  content = EXCLUDED.content,
+  updated_at = now();`);
+    }
+    return statements.join("\n\n");
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function loadServerEnv() {
+    const serverEnv = resolve(process.cwd(), "server", ".env");
+    if (!existsSync(serverEnv))
+        return {};
+    const content = readFileSync(serverEnv, "utf8");
+    const result = {};
+    for (const line of content.split("\n")) {
+        const match = line.match(/^([A-Z_]+)=(.+)$/);
+        if (match)
+            result[match[1]] = match[2].trim();
+    }
+    return result;
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,3 @@
+export declare function setup(options?: {
+    key?: string;
+}): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,149 @@
+import { createInterface } from "node:readline";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+import { saveApiKey, checkGitignore } from "../lib/config.js";
+import { validateKey, getDashboardUrl } from "../lib/api.js";
+import { ensureSkillsDir } from "../lib/paths.js";
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function setup(options = {}) {
+    console.log();
+    console.log(chalk.bold("  Skillett Setup"));
+    console.log();
+    // Check if already set up (skip in non-interactive mode)
+    const skillDir = resolve(process.cwd(), ".claude", "skills", "skillett");
+    if (!options.key && existsSync(resolve(skillDir, "SKILL.md"))) {
+        try {
+            const envContent = readFileSync(resolve(process.cwd(), ".env"), "utf8");
+            const existing = envContent.match(/^SKILLETT_API_KEY=(.+)$/m);
+            if (existing) {
+                console.log(chalk.green("  Already set up."));
+                console.log(chalk.gray(`  Key: ${existing[1].slice(0, 11)}…`));
+                console.log(chalk.gray(`  Skill: .claude/skills/skillett/`));
+                console.log();
+                const answer = await prompt("Reconfigure? (y/N) ");
+                if (answer.toLowerCase() !== "y") {
+                    return;
+                }
+                console.log();
+            }
+        }
+        catch {
+            // .env doesn't exist, continue
+        }
+    }
+    let key = options.key;
+    // If key provided via --key flag or SKILLETT_API_KEY env var, use it directly
+    if (!key) {
+        key = process.env.SKILLETT_API_KEY;
+    }
+    if (!key) {
+        // Interactive mode — prompt for key
+        const dashboardUrl = getDashboardUrl();
+        console.log(chalk.bold("  Get your API key from the Skillett dashboard:"));
+        console.log(chalk.cyan(`  ${dashboardUrl}/api-keys`));
+        console.log();
+        try {
+            await open(`${dashboardUrl}/api-keys`);
+        }
+        catch {
+            // Non-fatal — user can open manually
+        }
+        key = await prompt("  Paste your API key: ");
+    }
+    if (!key.startsWith("sk_")) {
+        console.log(chalk.red("  Invalid key format. Keys start with sk_"));
+        process.exit(1);
+    }
+    // Validate
+    const spinner = ora("  Validating key…").start();
+    const valid = await validateKey(key);
+    if (!valid) {
+        spinner.fail("  Invalid API key");
+        process.exit(1);
+    }
+    spinner.succeed("  Key validated");
+    // Save to .env
+    saveApiKey(key);
+    console.log(chalk.green("  ✓ Saved to .env"));
+    // Check .gitignore
+    if (!checkGitignore()) {
+        console.log(chalk.yellow("  ⚠ .env is not in your .gitignore — add it to avoid leaking your key"));
+    }
+    // Install core skill
+    ensureSkillsDir();
+    if (!existsSync(skillDir)) {
+        mkdirSync(skillDir, { recursive: true });
+    }
+    // Read from the real SKILL.md in the skills/skillett/ directory if available,
+    // otherwise use the bundled version
+    const repoSkillPath = resolve(process.cwd(), "skills", "skillett", "SKILL.md");
+    const coreSkillContent = existsSync(repoSkillPath)
+        ? readFileSync(repoSkillPath, "utf8")
+        : BUNDLED_SKILL_MD;
+    writeFileSync(resolve(skillDir, "SKILL.md"), coreSkillContent);
+    console.log(chalk.green("  ✓ Installed core skill to .claude/skills/skillett/"));
+    console.log();
+    console.log(chalk.bold("  You're all set! Your agent can now:"));
+    console.log("    • Discover skills:  GET /v1");
+    console.log("    • Install a skill:  npx skillett add github");
+    console.log("    • Execute:          POST /v1/{integration}/{endpoint}");
+    console.log();
+}
+const BUNDLED_SKILL_MD = `---
+name: skillett
+version: 1.0.0
+description: >
+  Skillett gateway — discover and execute agent skills for connected
+  integrations (GitHub, Slack, Gmail, etc.).
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Skillett
+
+You are connected to Skillett, an agent skills platform. Users connect
+their integrations (GitHub, Slack, Gmail, etc.) through the Skillett
+dashboard, and you interact with those services through the Skillett API.
+
+## Authentication
+
+Use the \`SKILLETT_API_KEY\` environment variable from the project's \`.env\`
+file. Include it as a Bearer token in all requests:
+
+    Authorization: Bearer $SKILLETT_API_KEY
+
+Base URL: \`https://api.skillett.dev\`
+
+## Discover Available Skills
+
+    GET /v1
+
+Returns your connected skills with status (ready, incomplete, error),
+install command, and endpoint count.
+
+## Execute an Endpoint
+
+    POST /v1/{integration}/{endpoint_name}
+    Content-Type: application/json
+
+    { "params": { ... } }
+
+## Install a Skill
+
+When you discover a ready skill, install its full docs:
+
+    npx skillett add {slug}
+
+This downloads the skill folder with detailed parameter docs for every endpoint.
+`;

package/dist/commands/skills.d.ts

@@ -0,0 +1 @@
+export declare function skills(integration?: string, endpoint?: string): Promise<void>;

package/dist/commands/skills.js

@@ -0,0 +1,50 @@
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+export async function skills(integration, endpoint) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.error(JSON.stringify({ error: "not_authenticated", message: "Run `skillett login` first." }));
+        process.exit(1);
+    }
+    const isTTY = process.stdout.isTTY;
+    // Level 3: Full endpoint docs
+    if (integration && endpoint) {
+        const spinner = isTTY ? ora("  Loading endpoint docs…").start() : null;
+        const res = await skillettFetch(`/v1/skills/${integration}/${endpoint}`, apiKey);
+        spinner?.stop();
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: "request_failed" }));
+            console.log(JSON.stringify(body, null, 2));
+            process.exit(1);
+        }
+        const data = await res.json();
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Level 2: List endpoints for integration
+    if (integration) {
+        const spinner = isTTY ? ora("  Loading endpoints…").start() : null;
+        const res = await skillettFetch(`/v1/skills/${integration}`, apiKey);
+        spinner?.stop();
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: "request_failed" }));
+            console.log(JSON.stringify(body, null, 2));
+            process.exit(1);
+        }
+        const data = await res.json();
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Level 1: List integrations
+    const spinner = isTTY ? ora("  Loading integrations…").start() : null;
+    const res = await skillettFetch("/v1/skills", apiKey);
+    spinner?.stop();
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "request_failed" }));
+        console.log(JSON.stringify(body, null, 2));
+        process.exit(1);
+    }
+    const data = await res.json();
+    console.log(JSON.stringify(data, null, 2));
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+export async function status() {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        const output = {
+            authenticated: false,
+            message: "Not logged in. Run `skillett login` to get started.",
+        };
+        if (process.stdout.isTTY) {
+            console.log();
+            console.log(chalk.yellow("  Not logged in."));
+            console.log(chalk.gray("  Run `skillett login` to get started."));
+            console.log();
+        }
+        else {
+            console.log(JSON.stringify(output, null, 2));
+        }
+        process.exit(1);
+    }
+    const isTTY = process.stdout.isTTY;
+    const spinner = isTTY ? ora("  Checking status…").start() : null;
+    // Fetch user info and skills in parallel
+    const [userRes, skillsRes] = await Promise.all([
+        skillettFetch("/auth/me", apiKey).catch(() => null),
+        skillettFetch("/v1/skills", apiKey).catch(() => null),
+    ]);
+    spinner?.stop();
+    const user = userRes?.ok ? await userRes.json() : null;
+    const skillsData = skillsRes?.ok ? await skillsRes.json() : null;
+    if (isTTY) {
+        console.log();
+        if (user) {
+            console.log(chalk.bold("  Account"));
+            console.log(`    Email: ${user.email || "—"}`);
+            console.log(`    Name:  ${user.display_name || "—"}`);
+            console.log(`    Key:   ${apiKey.slice(0, 11)}…`);
+        }
+        else {
+            console.log(chalk.red("  API key is invalid or expired."));
+            console.log(chalk.gray("  Run `skillett login` to re-authenticate."));
+        }
+        if (skillsData?.integrations?.length) {
+            console.log();
+            console.log(chalk.bold("  Integrations"));
+            for (const i of skillsData.integrations) {
+                const icon = i.status === "connected" ? chalk.green("●") : chalk.gray("○");
+                console.log(`    ${icon} ${i.name} (${i.slug}) — ${i.endpoints} endpoints`);
+            }
+        }
+        else if (skillsData) {
+            console.log();
+            console.log(chalk.gray("  No integrations connected."));
+            console.log(chalk.gray("  Run `skillett connect <integration>` to get started."));
+        }
+        console.log();
+    }
+    else {
+        console.log(JSON.stringify({
+            authenticated: !!user,
+            user,
+            integrations: skillsData?.integrations || [],
+        }, null, 2));
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare function whoami(): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,27 @@
+import chalk from "chalk";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { whoami as whoamiApi } from "../lib/api.js";
+export async function whoami() {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.log(chalk.red("Not logged in. Run: npx skillett login"));
+        process.exit(1);
+    }
+    const spinner = ora("Fetching user info…").start();
+    try {
+        const user = await whoamiApi(apiKey);
+        spinner.stop();
+        console.log();
+        console.log(chalk.bold("Logged in as:"));
+        console.log(`  ${chalk.cyan("Email:")}    ${user.email || "—"}`);
+        console.log(`  ${chalk.cyan("Name:")}     ${user.display_name || "—"}`);
+        console.log(`  ${chalk.cyan("ID:")}       ${user.id}`);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch user info");
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { loadEnv } from "./lib/config.js";
+loadEnv();
+import { Command } from "commander";
+import { login } from "./commands/login.js";
+import { skills } from "./commands/skills.js";
+import { run } from "./commands/run.js";
+import { status } from "./commands/status.js";
+import { connect } from "./commands/connect.js";
+import { disconnect } from "./commands/disconnect.js";
+import { pull } from "./commands/pull.js";
+import { seed } from "./commands/seed.js";
+const HELP_TEXT = `
+Skillett — Agent Skills Platform
+
+Connect and use external services (GitHub, Slack, Gmail, etc.) through CLI commands.
+
+COMMANDS
+
+  skillett login                  Authenticate with Skillett (opens browser)
+  skillett login --key <key>      Authenticate with an API key directly
+  skillett status                 Show current user, connections, and API key info
+  skillett skills                 List available integrations and connection status
+  skillett skills <integration>   List all endpoints for an integration
+  skillett skills <integ> <name>  Show full docs for a specific endpoint
+  skillett run <integ> <name>     Execute an endpoint
+  skillett connect <integration>  Connect an integration (opens browser for OAuth)
+  skillett disconnect <integ>     Disconnect an integration
+  skillett pull <integration>     Download skill docs locally for faster agent context
+  skillett help                   Show this help message
+
+QUICK START
+
+  skillett login                                      # authenticate
+  skillett skills                                     # see what's available
+  skillett run github create_issue \\
+    --repo acme/webapp --title "Fix login bug"        # execute
+
+PASSING PARAMETERS
+
+  As flags:    skillett run github create_issue --repo acme/webapp --title "Bug"
+  As JSON:     skillett run github create_issue '{"repo":"acme/webapp","title":"Bug"}'
+
+OUTPUT
+
+  All commands output JSON to stdout. Errors include an "error" field.
+  Exit code 0 = success, non-zero = failure.
+`;
+const program = new Command();
+program
+    .name("skillett")
+    .description("Skillett — Agent Skills Platform")
+    .version("0.2.0")
+    .addHelpText("after", HELP_TEXT);
+// Default action (no subcommand) — show help
+program.action(() => {
+    console.log(HELP_TEXT);
+});
+program
+    .command("login")
+    .description("Authenticate with Skillett (opens browser)")
+    .option("--key <api-key>", "API key (skips browser flow)")
+    .action(login);
+// Keep setup as hidden alias
+program
+    .command("setup", { hidden: true })
+    .option("--key <api-key>", "API key")
+    .action(login);
+program
+    .command("status")
+    .description("Show current user, connections, and API key info")
+    .action(status);
+program
+    .command("skills")
+    .description("List integrations, endpoints, or endpoint docs")
+    .argument("[integration]", "Integration slug (e.g. github)")
+    .argument("[endpoint]", "Endpoint name (e.g. create_issue)")
+    .action(skills);
+program
+    .command("run")
+    .description("Execute an endpoint")
+    .argument("<integration>", "Integration slug (e.g. github)")
+    .argument("<endpoint>", "Endpoint name (e.g. create_issue)")
+    .allowUnknownOption(true)
+    .action((integration, endpoint, _opts, cmd) => {
+    // Pass remaining args (--flags and positional JSON) to the run handler
+    const extraArgs = cmd.args.slice(2);
+    return run(integration, endpoint, extraArgs);
+});
+program
+    .command("connect")
+    .description("Connect an integration (opens browser for OAuth)")
+    .argument("<integration>", "Integration slug (e.g. github)")
+    .action(connect);
+program
+    .command("disconnect")
+    .description("Disconnect an integration")
+    .argument("<integration>", "Integration slug (e.g. github)")
+    .action(disconnect);
+program
+    .command("pull")
+    .description("Download skill docs locally for faster agent context")
+    .argument("<integration>", "Integration slug (e.g. github)")
+    .option("--path <dir>", "Custom output directory")
+    .action(pull);
+program
+    .command("seed", { hidden: true })
+    .argument("<skill-folder>", "Path to skill folder")
+    .option("--database-url <url>", "Postgres connection string")
+    .description("(Internal) Seed endpoints into the database from skill folder")
+    .action(seed);
+program.parse();