@withone/cli 1.43.9 → 1.44.0

package/README.md

@@ -144,11 +144,21 @@ In a monorepo, the project root is the nearest ancestor with `.one/`, `.git`, or
 
 If you've already set up, `one init` shows your current status for the active scope and lets you update your key, install to more agents, or reconfigure.
 
+**Agent-driven setup (no prompts).** Pass `--auth` and `one init` runs end-to-end without any terminal interaction — handy when an AI agent is onboarding you. It saves the key, auto-installs the One skill, and skips the connect step (`one add` later).
+
+```bash
+one init --auth browser            # opens a login window; you authenticate, the window closes — done
+one init --auth manual --api-key sk_live_...   # headless / CI, no browser
+```
+
 | Flag | What it does |
 |------|-------------|
 | `-y` | Skip confirmations |
 | `-g` | Non-interactive: write the One config globally (`~/.one/config.json`) |
 | `-p` | Non-interactive: write the One config for this project (`~/.one/projects/<slug>/config.json`) |
+| `--auth <browser\|manual>` | Run setup with **no prompts**. `browser` opens a login window; `manual` uses `--api-key`. Scope from `-g`/`-p` (default global). |
+| `--api-key <key>` | API key for `--auth manual` (`sk_live_…` / `sk_test_…`) |
+| `--openai-key <key>` | Optional OpenAI key for `one mem` semantic search |
 
 ### `one add <platform>`
 

package/dist/index.js

@@ -1046,8 +1046,12 @@ async function loginCommand() {
 
 // src/commands/init.ts
 async function initCommand(options) {
+  if (options.auth) {
+    await nonInteractiveInit(options);
+    return;
+  }
   if (isAgentMode()) {
-    error("This command requires interactive input. Run without --agent.");
+    error("This command is interactive. Run without --agent, or pass --auth <browser|manual> for a non-interactive setup.");
   }
   printBanner();
   const scope = await chooseConfigScope(options);
@@ -1062,6 +1066,101 @@ async function initCommand(options) {
   }
   await freshSetup(scope, options);
 }
+async function nonInteractiveInit(options) {
+  const auth = options.auth;
+  if (auth !== "browser" && auth !== "manual") {
+    error(`Invalid --auth value '${auth}'. Use 'browser' or 'manual'.`);
+  }
+  const scope = options.global ? "global" : options.project ? "project" : "global";
+  let apiKey;
+  let whoami;
+  if (auth === "browser") {
+    const result = await browserLogin();
+    if (!result) {
+      error("Browser login did not complete. Try again: one init --auth browser");
+    }
+    apiKey = result.apiKey;
+    whoami = result.whoami;
+  } else {
+    const key = options.apiKey?.trim();
+    if (!key) {
+      error("--auth manual requires --api-key <sk_live_\u2026 | sk_test_\u2026>.");
+    }
+    if (!key.startsWith("sk_live_") && !key.startsWith("sk_test_")) {
+      error("API key should start with sk_live_ or sk_test_.");
+    }
+    const api = new OneApi(key, getApiBase());
+    let validated;
+    try {
+      validated = await api.validateApiKey();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(`Could not validate API key: ${msg}`);
+    }
+    if (!validated) {
+      error(`Invalid API key. Get a valid key at ${getApiKeyUrl()}`);
+    }
+    apiKey = key;
+    whoami = validated;
+  }
+  const existing = scope === "project" ? readProjectConfig() : readGlobalConfig();
+  writeConfig(
+    {
+      apiKey,
+      installedAgents: existing?.installedAgents ?? [],
+      createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      accessControl: existing?.accessControl,
+      apiBase: existing?.apiBase,
+      cacheTtl: existing?.cacheTtl,
+      whoami
+    },
+    scope
+  );
+  if (options.openaiKey?.trim()) {
+    try {
+      setOpenAiApiKey(options.openaiKey.trim());
+    } catch {
+    }
+  }
+  const primaryIds = SKILL_AGENTS.filter((a) => a.primary).map((a) => a.id);
+  const { installed, failed } = installSkillForAgents(primaryIds);
+  const configPath = scope === "project" ? getProjectConfigPath() : getGlobalConfigPath();
+  if (isAgentMode()) {
+    json({
+      success: true,
+      scope,
+      configPath,
+      auth,
+      account: {
+        user: whoami.user,
+        organization: whoami.organization,
+        project: whoami.project,
+        env: getEnvFromApiKey(apiKey)
+      },
+      skillInstalled: installed,
+      skillFailed: failed
+    });
+    return;
+  }
+  const env = getEnvFromApiKey(apiKey);
+  const contextParts = [];
+  if (whoami.organization) contextParts.push(whoami.organization.name);
+  if (whoami.project) contextParts.push(whoami.project.name);
+  const scopeDisplay = contextParts.length > 0 ? contextParts.join(" / ") : "Personal";
+  const envLabel = env === "test" ? pc2.yellow("test") : pc2.green("live");
+  console.log();
+  console.log(`  ${pc2.bold("Setup complete")} ${scopeLabel(scope)}`);
+  console.log(`  ${pc2.dim("\u2500".repeat(42))}`);
+  console.log(`  ${pc2.dim("Account:")} ${scopeDisplay} ${pc2.dim("\xB7")} ${envLabel}`);
+  console.log(`  ${pc2.dim("User:")}    ${whoami.user.name} ${pc2.dim(`(${whoami.user.email})`)}`);
+  console.log(`  ${pc2.dim("Config:")}  ${tildify(configPath)}`);
+  if (installed.length > 0) {
+    console.log(`  ${pc2.dim("Skill:")}   ${pc2.green("installed")} ${pc2.dim("\xB7 " + installed.join(", "))}`);
+  }
+  console.log();
+  console.log(`  ${pc2.dim("Connect a platform later with")} ${pc2.cyan("one add <platform>")}`);
+  printOnboardingPrompt();
+}
 async function chooseConfigScope(options) {
   if (options.global) return "global";
   if (options.project) return "project";
@@ -9236,6 +9335,17 @@ var GUIDE_OVERVIEW = `# One CLI \u2014 Agent Guide
 
 You can also use \`one login\` / \`one logout\` to manage authentication separately (global or per-directory).
 
+### Agent-driven setup (no prompts)
+To onboard a user without any terminal interaction, pass \`--auth\` to \`one init\`. This disables every prompt, auto-installs the One skill, and skips the connect-a-platform step (run \`one add <platform>\` afterwards).
+
+\`\`\`bash
+one init --auth browser              # opens a login window; the user authenticates, the CLI saves the key
+one init --auth browser --project    # same, but scoped to this folder (default scope is global)
+one init --auth manual --api-key sk_live_...   # headless / CI \u2014 no browser
+\`\`\`
+
+With \`--auth browser\` the user sees a browser window, picks how to authenticate, and the window closes when done \u2014 the agent never blocks on stdin. Add \`--openai-key sk-...\` to enable semantic search in \`one mem\` during setup.
+
 ## The --agent Flag
 
 Always use \`--agent\` for machine-readable JSON output. It disables colors, spinners, and interactive prompts.
@@ -10640,7 +10750,7 @@ program.name("one").option("--agent", "Machine-readable JSON output (no colors,
   Setup:
     one login                             Authenticate via browser (opens app.withone.ai)
     one logout                            Clear local credentials
-    one init                              Set up API key and install MCP server
+    one init                              Set up API key + skill (add --auth browser for no-prompt agent setup)
     one add <platform>                    Connect a platform via OAuth (e.g. gmail, slack, shopify)
     one connection delete <key>           Remove a connection (alias: one connection rm)
     one config                            Configure access control (permissions, scoping)
@@ -10734,7 +10844,7 @@ program.hook("postAction", async () => {
   if (!isNewerVersion(info.version, current)) return;
   autoUpdate(info.version, info.publishedAt);
 });
-program.command("init").description("Set up One and install MCP to your AI agents (interactive: picks global or project scope)").option("-y, --yes", "Skip confirmations").option("-g, --global", "Write the One config globally (~/.one/config.json) \u2014 skips the scope picker").option("-p, --project", "Write the One config for this project only (~/.one/projects/<slug>/) \u2014 skips the scope picker").action(async (options) => {
+program.command("init").description("Set up One and install the skill to your AI agents (interactive; pass --auth for a no-prompt setup)").option("-y, --yes", "Skip confirmations").option("-g, --global", "Write the One config globally (~/.one/config.json) \u2014 skips the scope picker").option("-p, --project", "Write the One config for this project only (~/.one/projects/<slug>/) \u2014 skips the scope picker").option("--auth <method>", 'Non-interactive setup (no prompts): "browser" opens a login window, "manual" uses --api-key').option("--api-key <key>", "API key for --auth manual (sk_live_\u2026 or sk_test_\u2026)").option("--openai-key <key>", "Optional OpenAI key for `one mem` semantic search (non-interactive setup)").action(async (options) => {
   await initCommand(options);
 });
 program.command("login").description("Authenticate with One via browser").action(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.43.9",
+  "version": "1.44.0",
   "description": "CLI for managing One",
   "type": "module",
   "files": [

package/skills/one/SKILL.md

@@ -31,7 +31,9 @@ one login                    # Browser-based login (opens app.withone.ai)
 one logout                   # Clear local credentials
 ```
 
-`one login` opens the browser for OAuth authentication and automatically creates and stores an API key. If already logged in, the user can choose to log in globally or for the current directory. `one logout` shows current session info and confirms before clearing credentials. For CI/CD or headless environments, use `one init` to paste a key manually.
+`one login` opens the browser for OAuth authentication and automatically creates and stores an API key. If already logged in, the user can choose to log in globally or for the current directory. `one logout` shows current session info and confirms before clearing credentials.
+
+**Onboarding a user with no prompts:** run `one init --auth browser` — it opens a login window (the user authenticates there), saves the key, and auto-installs this skill, all without blocking on stdin. Add `-g`/`-p` for scope (default global). For CI/CD or headless environments, use `one init --auth manual --api-key sk_live_...`.
 
 ## Core Workflow: search -> knowledge -> execute