stpr 1.0.0

package/dist/cli.js

@@ -0,0 +1,810 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/auth.ts
+import * as childProcess from "child_process";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createServer } from "http";
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://mcp.stepper.io";
+var StepperClient = class {
+  token;
+  baseUrl;
+  requestId = 0;
+  constructor(token, baseUrl) {
+    this.token = token;
+    this.baseUrl = (baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  }
+  async rpc(method, params) {
+    const id = ++this.requestId;
+    const body = {
+      jsonrpc: "2.0",
+      method,
+      params: params ?? {},
+      id
+    };
+    const response = await fetch(`${this.baseUrl}/skill-sets/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return await response.json();
+  }
+  async initialize() {
+    const res = await this.rpc("initialize");
+    if (res.error) {
+      throw new Error(`Initialize failed: ${res.error.message}`);
+    }
+    await this.rpc("notifications/initialized");
+  }
+  async getServerInfo() {
+    const res = await this.rpc("initialize");
+    if (res.error) {
+      throw new Error(`Initialize failed: ${res.error.message}`);
+    }
+    const serverInfo = res.result?.serverInfo ?? {};
+    return {
+      name: serverInfo.name ?? "Unknown",
+      version: serverInfo.version ?? "1.0.0"
+    };
+  }
+  async listTools({ service }) {
+    const res = await this.rpc("tools/list");
+    if (res.error) {
+      throw new Error(`tools/list failed: ${res.error.message}`);
+    }
+    const tools = res.result.tools;
+    return tools.map(
+      (tool) => ({
+        service: tool.name.split(".")[0],
+        action: tool.name.split(".")[1],
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      })
+    ).filter(
+      (tool) => service ? tool.service === service : !tool.service.startsWith("__")
+    );
+  }
+  async callTool(name, args) {
+    const res = await this.rpc("tools/call", { name, arguments: args });
+    if (res.error) {
+      throw new Error(`tools/call failed: ${res.error.message}`);
+    }
+    return res.result;
+  }
+  async getToolParams(toolName, args) {
+    const res = await this.rpc("tools/params", {
+      name: toolName,
+      arguments: args
+    });
+    if (res.error) {
+      throw new Error(`tools/params failed: ${res.error.message}`);
+    }
+    return res.result;
+  }
+  async getParameterOptions(toolName, parameterId, opts) {
+    const res = await this.rpc("tools/options", {
+      name: toolName,
+      parameter_id: parameterId,
+      current_parameter_values: opts?.currentParameterValues ?? {},
+      search: opts?.search ?? null,
+      cursor: opts?.cursor ?? null
+    });
+    if (res.error) {
+      throw new Error(`tools/options failed: ${res.error.message}`);
+    }
+    return res.result;
+  }
+};
+
+// src/auth.ts
+function openBrowser(url) {
+  const platform2 = os.platform();
+  if (platform2 === "darwin") {
+    childProcess.spawn("open", [url], { stdio: "ignore", detached: true });
+  } else if (platform2 === "win32") {
+    childProcess.spawn("cmd", ["/c", "start", "", url], {
+      stdio: "ignore",
+      detached: true
+    });
+  } else {
+    childProcess.spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+  }
+}
+var DEFAULT_BASE_URL2 = "https://mcp.stepper.io";
+var OAUTH_CALLBACK_PORT = 3847;
+var CALLBACK_PATH = "/callback";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "stepper-skillsets");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var LEGACY_CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+function generatePKCE() {
+  const codeVerifier = crypto.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest().toString("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return { active: null, skillsets: {} };
+  }
+}
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    mode: 384
+  });
+}
+function migrateLegacyCredentials() {
+  try {
+    const data = fs.readFileSync(LEGACY_CREDENTIALS_FILE, "utf-8");
+    const creds = JSON.parse(data);
+    const config = {
+      active: "default",
+      skillsets: { default: creds }
+    };
+    saveConfig(config);
+    fs.unlinkSync(LEGACY_CREDENTIALS_FILE);
+  } catch {
+  }
+}
+function getConfigPathForDisplay() {
+  return CONFIG_FILE;
+}
+function getActiveSkillset() {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  return config.active;
+}
+function setActiveSkillset(name) {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  if (!(name in config.skillsets)) {
+    return false;
+  }
+  config.active = name;
+  saveConfig(config);
+  return true;
+}
+function listSkillsets() {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  return Object.entries(config.skillsets).map(([name, creds]) => ({
+    name,
+    baseUrl: creds.baseUrl,
+    isActive: config.active === name
+  }));
+}
+function getCredentials(name) {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  return config.skillsets[name] ?? null;
+}
+function saveCredentials(name, creds) {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  config.skillsets[name] = creds;
+  if (!config.active || !(config.active in config.skillsets)) {
+    config.active = name;
+  }
+  saveConfig(config);
+}
+function deleteSkillset(name) {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  if (!(name in config.skillsets)) {
+    return false;
+  }
+  delete config.skillsets[name];
+  if (config.active === name) {
+    config.active = Object.keys(config.skillsets)[0] ?? null;
+  }
+  saveConfig(config);
+  return true;
+}
+function deleteAllSkillsets() {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  const count = Object.keys(config.skillsets).length;
+  config.skillsets = {};
+  config.active = null;
+  saveConfig(config);
+  return count;
+}
+async function fetchMetadata(baseUrl) {
+  const url = `${baseUrl.replace(/\/$/, "")}/.well-known/oauth-authorization-server`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch OAuth metadata: ${res.status} ${await res.text()}`
+    );
+  }
+  return await res.json();
+}
+async function registerClient(baseUrl, redirectUri) {
+  const url = `${baseUrl.replace(/\/$/, "")}/register`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_name: "Skills CLI",
+      redirect_uris: [redirectUri],
+      grant_types: ["authorization_code", "refresh_token"],
+      token_endpoint_auth_method: "none",
+      response_types: ["code"]
+    })
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to register client: ${res.status} ${await res.text()}`
+    );
+  }
+  const data = await res.json();
+  return data.client_id;
+}
+async function exchangeCodeForTokens(baseUrl, clientId, redirectUri, code, codeVerifier) {
+  const url = `${baseUrl.replace(/\/$/, "")}/token`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      code,
+      code_verifier: codeVerifier
+    }).toString()
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token exchange failed: ${res.status} ${text}`);
+  }
+  const data = await res.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in ?? 3600
+  };
+}
+function extractSkillSetNameFromServerName(serverName) {
+  const prefix = "Stepper MCP Server - ";
+  if (serverName.startsWith(prefix)) {
+    return serverName.slice(prefix.length).trim() || serverName;
+  }
+  return serverName;
+}
+async function runLoginFlow(baseUrl) {
+  const mcpBaseUrl = baseUrl ?? process.env.STEPPER_URL ?? DEFAULT_BASE_URL2;
+  const normalizedBaseUrl = mcpBaseUrl.replace(/\/$/, "");
+  const redirectUri = `http://127.0.0.1:${OAUTH_CALLBACK_PORT}${CALLBACK_PATH}`;
+  const metadata = await fetchMetadata(normalizedBaseUrl);
+  const { codeVerifier, codeChallenge } = generatePKCE();
+  const clientId = await registerClient(normalizedBaseUrl, redirectUri);
+  const state = crypto.randomBytes(16).toString("hex");
+  const authUrl = new URL(metadata.authorization_endpoint);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("state", state);
+  return new Promise((resolve, reject) => {
+    const server = createServer(
+      (req, res) => {
+        const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+        if (url.pathname !== CALLBACK_PATH) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            `<html><body><h1>Login failed</h1><p>${error}: ${url.searchParams.get("error_description") ?? "Unknown error"}</p><p>You can close this tab.</p></body></html>`
+          );
+          server.close();
+          reject(new Error(`OAuth error: ${error}`));
+          return;
+        }
+        if (returnedState !== state) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h1>Login failed</h1><p>State mismatch</p><p>You can close this tab.</p></body></html>"
+          );
+          server.close();
+          reject(new Error("OAuth state mismatch"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("Missing authorization code");
+          server.close();
+          reject(new Error("Missing authorization code"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Login successful</h1><p>You can close this tab and return to the terminal.</p></body></html>"
+        );
+        exchangeCodeForTokens(
+          normalizedBaseUrl,
+          clientId,
+          redirectUri,
+          code,
+          codeVerifier
+        ).then(async ({ accessToken, refreshToken, expiresIn }) => {
+          const creds = {
+            baseUrl: normalizedBaseUrl,
+            clientId,
+            accessToken,
+            refreshToken,
+            expiresAt: new Date(Date.now() + expiresIn * 1e3).toISOString()
+          };
+          let name;
+          try {
+            const client = new StepperClient(accessToken, normalizedBaseUrl);
+            const serverInfo = await client.getServerInfo();
+            name = extractSkillSetNameFromServerName(serverInfo.name);
+          } catch {
+            name = `unknown-${Date.now()}`;
+          }
+          saveCredentials(name, creds);
+          resolve({ credentials: creds, name });
+        }).catch(reject).finally(() => server.close());
+      }
+    );
+    server.listen(OAUTH_CALLBACK_PORT, "127.0.0.1", () => {
+      openBrowser(authUrl.toString());
+    });
+    server.on("error", reject);
+  });
+}
+async function refreshAccessToken(baseUrl, clientId, refreshToken) {
+  const url = `${baseUrl.replace(/\/$/, "")}/token`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: clientId,
+      refresh_token: refreshToken
+    }).toString()
+  });
+  if (!res.ok) {
+    throw new Error(`Token refresh failed: ${res.status}`);
+  }
+  const data = await res.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in ?? 3600
+  };
+}
+async function getValidToken(skillsetName, baseUrl) {
+  migrateLegacyCredentials();
+  const config = loadConfig();
+  const name = skillsetName ?? config.active;
+  if (!name || !(name in config.skillsets)) {
+    return null;
+  }
+  const creds = config.skillsets[name];
+  const resolvedBaseUrl = baseUrl ?? process.env.STEPPER_URL ?? creds.baseUrl;
+  if (creds.baseUrl !== resolvedBaseUrl) {
+    return null;
+  }
+  const expiresAt = new Date(creds.expiresAt).getTime();
+  const now = Date.now();
+  const bufferSeconds = 60;
+  if (expiresAt > now + bufferSeconds * 1e3) {
+    return {
+      token: creds.accessToken,
+      baseUrl: creds.baseUrl,
+      skillsetName: name
+    };
+  }
+  if (!creds.clientId || !creds.refreshToken) {
+    return null;
+  }
+  try {
+    const refreshed = await refreshAccessToken(
+      creds.baseUrl,
+      creds.clientId,
+      creds.refreshToken
+    );
+    const newCreds = {
+      ...creds,
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken,
+      expiresAt: new Date(
+        Date.now() + refreshed.expiresIn * 1e3
+      ).toISOString()
+    };
+    saveCredentials(name, newCreds);
+    return {
+      token: newCreds.accessToken,
+      baseUrl: creds.baseUrl,
+      skillsetName: name
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/cli.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var pkg = createRequire(import.meta.url)(
+  path2.join(__dirname, "..", "package.json")
+);
+var VERSION = pkg.version ?? "0.0.0";
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on(
+      "end",
+      () => resolve(Buffer.concat(chunks).toString("utf-8"))
+    );
+    process.stdin.on("error", reject);
+    if (process.stdin.isTTY) {
+      resolve("");
+    }
+  });
+}
+function parseArgs(argv) {
+  const flags = {};
+  const boolFlags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--token" && i + 1 < argv.length) {
+      flags.token = argv[++i];
+    } else if (arg === "--base-url" && i + 1 < argv.length) {
+      flags.baseUrl = argv[++i];
+    } else if (arg === "--skillset" && i + 1 < argv.length) {
+      flags.skillset = argv[++i];
+    } else if ((arg === "--input" || arg === "-i") && i + 1 < argv.length) {
+      flags.input = argv[++i];
+    } else if (arg === "--search" && i + 1 < argv.length) {
+      flags.search = argv[++i];
+    } else if (arg === "--cursor" && i + 1 < argv.length) {
+      flags.cursor = argv[++i];
+    } else if (arg === "--call") {
+      boolFlags.call = true;
+    } else if (arg === "--verbose") {
+      boolFlags.verbose = true;
+    } else if (arg === "--options" && i + 1 < argv.length) {
+      flags.options = argv[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      positional.unshift("help");
+    } else if (arg === "--version" || arg === "-v") {
+      positional.unshift("version");
+    } else {
+      positional.push(arg);
+    }
+  }
+  return {
+    subcommand: positional[0] ?? "help",
+    args: positional.slice(1),
+    token: flags.token,
+    baseUrl: flags.baseUrl,
+    skillset: flags.skillset,
+    input: flags.input,
+    search: flags.search,
+    cursor: flags.cursor,
+    call: boolFlags.call ?? false,
+    verbose: boolFlags.verbose ?? false,
+    options: flags.options
+  };
+}
+function toToolName(service, action) {
+  return `${service}.${action}`;
+}
+function formatToolsForList(tools, verbose) {
+  if (verbose) {
+    return tools;
+  }
+  const out = {};
+  for (const tool of tools) {
+    out[tool.service] = [...out[tool.service] || [], tool.action];
+  }
+  return out;
+}
+function printUsage() {
+  console.error(`stpr v${VERSION}
+
+Usage: stpr <command> [options]
+
+Commands:
+  version              Show version
+  login                Log in via OAuth (opens browser). Named after the skillset from Stepper
+  logout [name]        Log out and remove a skillset. Omit name to remove all skillsets.
+  profiles             List all stored skillsets
+  use <name>           Switch active skillset
+  whoami               Show active skillset and server info
+  list [<service>]      List available skills (optionally for a service). Use --verbose for inputSchema.
+  <service>             List available skills for that service. Use --verbose for inputSchema.
+ 
+  <service> <action> (-i <json> | stdin)
+                       Get the current parameters for a skill (default, for dynamic parameters)
+  <service> <action> --call (-i <json> | stdin)
+                       Call a skill (JSON via --input, -i, or stdin)
+  <service> <action> --options <parameter> (--search <query> --cursor <cursor> -i <json>)
+                       Fetch dynamic dropdown options for a parameter
+
+Options:
+  --token <token>     Auth token (or set STEPPER_SKILL_TOKEN env var)
+  --base-url <url>    Override base URL (or set STEPPER_URL env var)
+  --skillset <name>   Use a specific skill set
+  --call              Execute the skill (default is to fetch parameters only)
+  --verbose           Include inputSchema when listing skills
+  -i, --input <json>  JSON input for call, parameters or options (alternative to stdin)
+  --search <query>    Search query for dynamic dropdown options
+  --cursor <cursor>   Pagination cursor for dynamic dropdown options
+  -h, --help          Show this help message
+  -v, --version       Show version
+
+Examples:
+
+  Auth (optional, can use STEPPER_SKILL_TOKEN env var, or --token <token> from https://app.stepper.io/flow/skill-sets):
+    stpr login
+
+  List available skills:
+    stpr list
+    stpr stripe
+
+
+  Load parameters:
+    By default, requesting a skill returns the current parameters only; it does
+    not call the skill. Use --call to execute the action.
+
+    skillset google-sheets add_row -i '{"spreadsheet_id": "abc123"}'
+
+  Call a skill:
+    skillset stripe create_customer --call -i '{"email": "test@example.com"}'
+
+  Dynamic dropdown options:
+    Some actions have dynamic dropdown options, which change depending on the
+    value of other parameters. You can request the current dropdown options for
+    a skill by using the --options flag. This will return the current dropdown
+    options only, it will not call the skill. Dynamic dropdowns are also often
+    searchable and paginated via a cursor.
+
+    stpr google-sheets addRow --options worksheet_id -i '{"spreadsheet_id": "abc123"}'
+    stpr google-sheets addRow --options worksheet_id --search "Sheet" --cursor "next_page"
+
+Profiles:
+  Multiple skill sets stored in ~/.config/stepper-skillsets/
+  Precedence: --token > STEPPER_SKILL_TOKEN > --skillset > active skill set`);
+}
+function die(message) {
+  process.stderr.write(`\x1B[31m[Error] ${message} \x1B[0m 
+`);
+  process.exit(1);
+}
+async function main() {
+  const {
+    subcommand,
+    args,
+    token: flagToken,
+    baseUrl,
+    skillset: flagSkillset,
+    input: inputFlag,
+    search: searchFlag,
+    cursor: cursorFlag,
+    call: callFlag,
+    verbose: verboseFlag,
+    options: optionsFlag
+  } = parseArgs(process.argv.slice(2));
+  if (subcommand === "help") {
+    printUsage();
+    process.exit(0);
+  }
+  if (subcommand === "version" || subcommand === "-v" || subcommand === "--version") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (subcommand === "login") {
+    try {
+      process.stderr.write("Opening browser for authentication...\n");
+      const { name } = await runLoginFlow(baseUrl);
+      process.stderr.write(
+        `Logged in successfully. Credentials saved as "${name}" in `
+      );
+      process.stderr.write(`${getConfigPathForDisplay()}
+`);
+    } catch (err) {
+      die(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  if (subcommand === "logout") {
+    const name = args[0];
+    if (name) {
+      const removed = deleteSkillset(name);
+      process.stderr.write(
+        removed ? `Removed skillset "${name}".
+` : `Skillset "${name}" not found.
+`
+      );
+    } else {
+      const count = deleteAllSkillsets();
+      if (count > 0) {
+        process.stderr.write(
+          `Removed ${count} skillset${count > 1 ? "s" : ""}.
+`
+        );
+      } else {
+        process.stderr.write("No skillset to remove.\n");
+      }
+    }
+    return;
+  }
+  if (subcommand === "use") {
+    const name = args[0];
+    if (!name) {
+      die("Usage: skillset use <name>");
+    }
+    const ok = setActiveSkillset(name);
+    if (!ok) {
+      die(`Skillset "${name}" not found. Run "skillset profiles" to list.`);
+    }
+    process.stderr.write(`Switched to skillset "${name}".
+`);
+    return;
+  }
+  if (subcommand === "whoami") {
+    const skillsetName2 = flagSkillset ?? getActiveSkillset();
+    if (!skillsetName2) {
+      die('No active skillset. Run "stpr login" or "stpr use <name>".');
+    }
+    const stored = await getValidToken(skillsetName2);
+    if (!stored) {
+      const creds = getCredentials(skillsetName2);
+      if (!creds) {
+        die(`Skillset "${skillsetName2}" not found.`);
+      }
+      die(
+        `Skillset "${skillsetName2}" has expired or invalid token. Run "skills login" to re-authenticate.`
+      );
+    }
+    const client2 = new StepperClient(stored.token, stored.baseUrl);
+    try {
+      const serverInfo = await client2.getServerInfo();
+      console.log(
+        JSON.stringify(
+          {
+            skillSet: stored.skillsetName,
+            baseUrl: stored.baseUrl,
+            serverName: serverInfo.name,
+            serverVersion: serverInfo.version
+          },
+          null,
+          2
+        )
+      );
+    } catch (err) {
+      console.log(
+        JSON.stringify(
+          {
+            skillSet: stored.skillsetName,
+            baseUrl: stored.baseUrl,
+            error: err instanceof Error ? err.message : String(err)
+          },
+          null,
+          2
+        )
+      );
+    }
+    return;
+  }
+  if (subcommand === "profiles" || subcommand === "skillsets") {
+    const sets = listSkillsets();
+    if (sets.length === 0) {
+      process.stderr.write(
+        'No skillset configured. Run "skillset login" to add one.\n'
+      );
+      return;
+    }
+    for (const s of sets) {
+      const marker = s.isActive ? " (active)" : "";
+      process.stderr.write(`${s.name}${marker}: ${s.baseUrl}
+`);
+    }
+    return;
+  }
+  let token = flagToken ?? process.env.STEPPER_SKILL_TOKEN;
+  let resolvedBaseUrl = baseUrl ?? process.env.STEPPER_URL;
+  const skillsetName = flagSkillset ?? getActiveSkillset();
+  if (!token) {
+    const stored = await getValidToken(
+      skillsetName ?? void 0,
+      resolvedBaseUrl
+    );
+    if (stored) {
+      token = stored.token;
+      resolvedBaseUrl = stored.baseUrl;
+    }
+  }
+  if (!token) {
+    die(
+      'No token provided. Run "skillset login" or use --token or set STEPPER_SKILL_TOKEN env var.'
+    );
+  }
+  const client = new StepperClient(token, resolvedBaseUrl);
+  await client.initialize();
+  if (subcommand === "list") {
+    const service2 = args[0];
+    const tools = await client.listTools({ service: service2 ?? void 0 });
+    const formatted = formatToolsForList(tools, verboseFlag);
+    console.log(JSON.stringify(formatted, null, 2));
+    return;
+  }
+  const service = subcommand;
+  const action = args[0];
+  if (service.startsWith("--")) {
+    printUsage();
+    process.exit(1);
+    return;
+  }
+  if (!action) {
+    const tools = await client.listTools({ service });
+    const formatted = verboseFlag ? formatToolsForList(tools, verboseFlag) : tools.map(({ action: action2 }) => action2);
+    console.log(JSON.stringify(formatted, null, 2));
+    return;
+  }
+  const toolName = toToolName(service, action);
+  const rawInput = inputFlag ?? await readStdin();
+  let input = {};
+  if (rawInput.trim()) {
+    try {
+      input = JSON.parse(rawInput);
+    } catch {
+      die("Invalid JSON input.");
+    }
+  }
+  if (optionsFlag) {
+    const result2 = await client.getParameterOptions(toolName, optionsFlag, {
+      currentParameterValues: input,
+      search: searchFlag,
+      cursor: cursorFlag
+    });
+    console.log(JSON.stringify(result2, null, 2));
+    return;
+  }
+  if (callFlag) {
+    const result2 = await client.callTool(toolName, input);
+    if (result2.isError) {
+      die(result2.content.map((c) => c.text).join("\n"));
+    }
+    console.log(result2.content.map((c) => c.text ?? "").join("\n"));
+    return;
+  }
+  const result = await client.getToolParams(toolName, input);
+  if (result.isError) {
+    die(result.content?.map((c) => c.text).join("\n") ?? "Unknown error");
+  }
+  console.log(JSON.stringify(result, null, 2));
+}
+main().then(() => process.exit(0)).catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "stpr",
+  "version": "1.0.0",
+  "description": "CLI for Stepper skill sets",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "stpr": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}