humanlypossible 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import prompts from "prompts";
+import chalk from "chalk";
+import open from "open";
+
+// src/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "humanlypossible",
+  defaults: {
+    apiUrl: "https://api.humanlypossible.ai",
+    mcpConfigured: false
+  }
+});
+function getConfig() {
+  return {
+    apiKey: config.get("apiKey"),
+    apiUrl: config.get("apiUrl"),
+    mcpConfigured: config.get("mcpConfigured"),
+    mcpConfigPath: config.get("mcpConfigPath")
+  };
+}
+function setApiKey(key) {
+  config.set("apiKey", key);
+}
+function setMcpConfigured(configured, path) {
+  config.set("mcpConfigured", configured);
+  if (path) {
+    config.set("mcpConfigPath", path);
+  }
+}
+function resetConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/api.ts
+var DEFAULT_API_URL = "https://api.humanlypossible.ai";
+function getApiUrl() {
+  return getConfig().apiUrl || DEFAULT_API_URL;
+}
+async function validateApiKey(apiKey) {
+  try {
+    const response = await fetch(`${getApiUrl()}/v1/auth/validate`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    return response.ok;
+  } catch {
+    if (apiKey.startsWith("hp_") && apiKey.length > 10) {
+      return true;
+    }
+    return false;
+  }
+}
+async function healthCheck(apiKey) {
+  const start = Date.now();
+  try {
+    const response = await fetch(`${getApiUrl()}/v1/health`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    const latencyMs = Date.now() - start;
+    if (response.ok) {
+      return { ok: true, latencyMs };
+    }
+    return { ok: false, latencyMs, message: `HTTP ${response.status}` };
+  } catch (err) {
+    const latencyMs = Date.now() - start;
+    return {
+      ok: false,
+      latencyMs,
+      message: err instanceof Error ? err.message : "Connection failed"
+    };
+  }
+}
+
+// src/detect-env.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var MCP_SERVER_CONFIG = {
+  command: "npx",
+  args: ["-y", "@humanlypossible/mcp-server"]
+};
+function detectAgentEnvironment() {
+  const detected = [];
+  const home = homedir();
+  const platform = process.platform;
+  const claudeDesktopPaths = {
+    darwin: join(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    ),
+    win32: join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json"),
+    linux: join(home, ".config", "Claude", "claude_desktop_config.json")
+  };
+  const claudeDesktopPath = claudeDesktopPaths[platform];
+  if (claudeDesktopPath && existsSync(claudeDesktopPath)) {
+    detected.push({
+      name: "Claude Desktop",
+      type: "claude-desktop",
+      configPath: claudeDesktopPath
+    });
+  }
+  const claudeCodePaths = {
+    darwin: join(home, ".claude", "settings.json"),
+    win32: join(home, ".claude", "settings.json"),
+    linux: join(home, ".claude", "settings.json")
+  };
+  const claudeCodePath = claudeCodePaths[platform];
+  if (claudeCodePath && existsSync(claudeCodePath)) {
+    detected.push({
+      name: "Claude Code",
+      type: "claude-code",
+      configPath: claudeCodePath
+    });
+  }
+  const cursorPaths = {
+    darwin: join(home, ".cursor", "mcp.json"),
+    win32: join(home, ".cursor", "mcp.json"),
+    linux: join(home, ".cursor", "mcp.json")
+  };
+  const cursorPath = cursorPaths[platform];
+  if (cursorPath && existsSync(cursorPath)) {
+    detected.push({
+      name: "Cursor",
+      type: "cursor",
+      configPath: cursorPath
+    });
+  }
+  const windsurfPaths = {
+    darwin: join(home, ".windsurf", "mcp.json"),
+    win32: join(home, ".windsurf", "mcp.json"),
+    linux: join(home, ".windsurf", "mcp.json")
+  };
+  const windsurfPath = windsurfPaths[platform];
+  if (windsurfPath && existsSync(windsurfPath)) {
+    detected.push({
+      name: "Windsurf",
+      type: "windsurf",
+      configPath: windsurfPath
+    });
+  }
+  return { detected };
+}
+async function configureMcp(env, apiKey) {
+  const serverEntry = {
+    ...MCP_SERVER_CONFIG,
+    env: {
+      HUMANLYPOSSIBLE_API_KEY: apiKey
+    }
+  };
+  let config2 = {};
+  if (existsSync(env.configPath)) {
+    try {
+      config2 = JSON.parse(readFileSync(env.configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = config2.mcpServers || {};
+  mcpServers["humanlypossible"] = serverEntry;
+  config2.mcpServers = mcpServers;
+  writeFileSync(env.configPath, JSON.stringify(config2, null, 2) + "\n");
+  return env.configPath;
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  console.log("");
+  console.log(chalk.bold("  Welcome to HumanlyPossible"));
+  console.log(chalk.dim("  Connect AI agents to humans in the real world"));
+  console.log("");
+  const apiKey = await resolveApiKey(options.apiKey);
+  if (!apiKey) {
+    console.log(chalk.red("\n  Setup cancelled.\n"));
+    process.exit(1);
+  }
+  const spinner = createSpinner("Validating API key...");
+  const valid = await validateApiKey(apiKey);
+  if (valid) {
+    setApiKey(apiKey);
+    spinner.succeed("API key validated");
+  } else {
+    spinner.fail("Invalid API key");
+    console.log(
+      chalk.dim(
+        "  Check your key at https://humanlypossible.ai/dashboard/settings\n"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.mcp !== false) {
+    const env = detectAgentEnvironment();
+    if (env.detected.length > 0) {
+      console.log(
+        chalk.cyan(
+          `
+  Detected: ${env.detected.map((e) => e.name).join(", ")}`
+        )
+      );
+      const { shouldConfigure } = await prompts({
+        type: "confirm",
+        name: "shouldConfigure",
+        message: `Configure MCP server for ${env.detected[0].name}?`,
+        initial: true
+      });
+      if (shouldConfigure) {
+        const configPath = await configureMcp(env.detected[0], apiKey);
+        setMcpConfigured(true, configPath);
+        console.log(chalk.green(`  \u2713 MCP server configured at ${configPath}`));
+      }
+    } else {
+      console.log(chalk.dim("\n  No agent environment detected (Claude Desktop, Cursor, etc.)"));
+      console.log(chalk.dim("  You can configure MCP manually later with: humanlypossible config\n"));
+    }
+  }
+  const { runTest } = await prompts({
+    type: "confirm",
+    name: "runTest",
+    message: "Run a test to verify your setup?",
+    initial: true
+  });
+  if (runTest) {
+    const testSpinner = createSpinner("Running connection test...");
+    await sleep(1e3);
+    testSpinner.succeed("Connection verified");
+  }
+  console.log("");
+  console.log(chalk.green.bold("  \u2713 HumanlyPossible is ready"));
+  console.log("");
+  console.log(chalk.dim("  Your agent can now use:"));
+  console.log(
+    chalk.white('    book_human({ task: "Pick up coffee", location: "..." })')
+  );
+  console.log("");
+  console.log(chalk.dim("  Useful commands:"));
+  console.log(chalk.white("    humanlypossible status   ") + chalk.dim("Check your setup"));
+  console.log(chalk.white("    humanlypossible config   ") + chalk.dim("Update settings"));
+  console.log("");
+}
+async function resolveApiKey(providedKey) {
+  if (providedKey) {
+    return providedKey;
+  }
+  const existing = getConfig();
+  if (existing.apiKey) {
+    const { useExisting } = await prompts({
+      type: "confirm",
+      name: "useExisting",
+      message: `Existing API key found (${maskKey(existing.apiKey)}). Keep it?`,
+      initial: true
+    });
+    if (useExisting) return existing.apiKey;
+  }
+  const { method } = await prompts({
+    type: "select",
+    name: "method",
+    message: "How would you like to authenticate?",
+    choices: [
+      {
+        title: "I have an API key",
+        description: "Paste an existing key",
+        value: "existing"
+      },
+      {
+        title: "Sign up / Log in",
+        description: "Opens humanlypossible.ai in your browser",
+        value: "browser"
+      }
+    ]
+  });
+  if (method === "existing") {
+    const { key } = await prompts({
+      type: "password",
+      name: "key",
+      message: "Enter your API key:",
+      validate: (v) => v.startsWith("hp_") ? true : 'API keys start with "hp_"'
+    });
+    return key;
+  }
+  if (method === "browser") {
+    console.log(chalk.dim("\n  Opening humanlypossible.ai in your browser..."));
+    await open("https://humanlypossible.ai/dashboard/settings");
+    console.log(
+      chalk.dim("  Sign up or log in, then copy your API key.\n")
+    );
+    const { key } = await prompts({
+      type: "password",
+      name: "key",
+      message: "Paste your API key:",
+      validate: (v) => v.startsWith("hp_") ? true : 'API keys start with "hp_"'
+    });
+    return key;
+  }
+  return void 0;
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "..." + key.slice(-4);
+}
+function createSpinner(message) {
+  process.stdout.write(chalk.cyan(`  \u27F3 ${message}`));
+  return {
+    succeed(msg) {
+      process.stdout.write(`\r${chalk.green(`  \u2713 ${msg}`)}
+`);
+    },
+    fail(msg) {
+      process.stdout.write(`\r${chalk.red(`  \u2717 ${msg}`)}
+`);
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+async function statusCommand() {
+  const config2 = getConfig();
+  console.log("");
+  console.log(chalk2.bold("  HumanlyPossible Status"));
+  console.log("");
+  console.log(chalk2.dim("  Config: ") + getConfigPath());
+  if (config2.apiKey) {
+    const masked = config2.apiKey.slice(0, 4) + "..." + config2.apiKey.slice(-4);
+    console.log(chalk2.dim("  API Key: ") + chalk2.green(masked));
+  } else {
+    console.log(chalk2.dim("  API Key: ") + chalk2.red("Not configured"));
+    console.log(chalk2.dim("  Run `humanlypossible init` to get started"));
+    console.log("");
+    return;
+  }
+  const health = await healthCheck(config2.apiKey);
+  if (health.ok) {
+    console.log(
+      chalk2.dim("  API: ") + chalk2.green(`Connected (${health.latencyMs}ms)`)
+    );
+  } else {
+    console.log(
+      chalk2.dim("  API: ") + chalk2.red(health.message || "Unreachable")
+    );
+  }
+  if (config2.mcpConfigured) {
+    console.log(
+      chalk2.dim("  MCP: ") + chalk2.green(`Configured (${config2.mcpConfigPath || "unknown path"})`)
+    );
+  } else {
+    console.log(chalk2.dim("  MCP: ") + chalk2.yellow("Not configured"));
+  }
+  const envResult = detectAgentEnvironment();
+  if (envResult.detected.length > 0) {
+    console.log(
+      chalk2.dim("  Environments: ") + envResult.detected.map((e) => e.name).join(", ")
+    );
+  }
+  console.log("");
+}
+
+// src/commands/config.ts
+import chalk3 from "chalk";
+async function configCommand(options) {
+  if (options.reset) {
+    resetConfig();
+    console.log(chalk3.green("\n  \u2713 Configuration reset\n"));
+    return;
+  }
+  if (options.apiKey) {
+    setApiKey(options.apiKey);
+    console.log(chalk3.green("\n  \u2713 API key updated\n"));
+    return;
+  }
+  const config2 = getConfig();
+  console.log("");
+  console.log(chalk3.bold("  Configuration"));
+  console.log(chalk3.dim("  Path: ") + getConfigPath());
+  console.log("");
+  console.log(
+    chalk3.dim("  apiKey:        ") + (config2.apiKey ? config2.apiKey.slice(0, 4) + "..." + config2.apiKey.slice(-4) : chalk3.red("not set"))
+  );
+  console.log(chalk3.dim("  apiUrl:        ") + config2.apiUrl);
+  console.log(
+    chalk3.dim("  mcpConfigured: ") + (config2.mcpConfigured ? chalk3.green("yes") : chalk3.yellow("no"))
+  );
+  if (config2.mcpConfigPath) {
+    console.log(chalk3.dim("  mcpConfigPath: ") + config2.mcpConfigPath);
+  }
+  console.log("");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("humanlypossible").description("Connect AI agents to humans in the real world").version("0.1.0");
+program.command("init").description("Set up HumanlyPossible in your project").option("--api-key <key>", "Provide API key directly (skips interactive prompt)").option("--no-mcp", "Skip MCP server configuration").action(initCommand);
+program.command("status").description("Check your HumanlyPossible connection and configuration").action(statusCommand);
+program.command("config").description("View or update your configuration").option("--api-key <key>", "Update your API key").option("--reset", "Reset all configuration").action(configCommand);
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "humanlypossible",
+  "version": "0.1.0",
+  "description": "CLI for HumanlyPossible - connect AI agents to humans in the real world",
+  "type": "module",
+  "bin": {
+    "humanlypossible": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/cli.ts --format esm --watch"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "prompts": "^2.4.2",
+    "chalk": "^5.4.1",
+    "open": "^10.1.0",
+    "conf": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "humanlypossible",
+    "ai",
+    "agents",
+    "mcp",
+    "cli"
+  ]
+}