@primitivedotdev/cli 1.2.0 → 1.2.1

package/README.md

@@ -16,6 +16,8 @@ primitive whoami
 prim whoami
 ```
 
+The same CLI is also published unscoped as [`primcli`](https://www.npmjs.com/package/primcli) — `npm install -g primcli` installs an identical build with the same `primitive`/`prim` commands. Use whichever name you prefer; they track the same version.
+
 Or with no install:
 
 ```bash

package/dist/oclif/index.js

@@ -2,7 +2,7 @@ import { A as PrimitiveApiClient, C as saveCliCredentials, D as loadActiveChatSt
 import { Args, Command, Errors, Flags, ux } from "@oclif/core";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import path, { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { hostname } from "node:os";
 import process$1 from "node:process";
 import { createInterface } from "node:readline/promises";
@@ -20942,6 +20942,74 @@ var SignupCommand = class SignupCommand extends Command {
 		}
 	}
 };
+function resolveVerificationCode(input) {
+	const sources = [
+		input.positional !== void 0 ? "positional" : null,
+		input.fromStdin === true ? "--code-from-stdin" : null,
+		input.fromFile !== void 0 ? "--code-from-file" : null,
+		input.fromEnv !== void 0 ? "--code-from-env" : null
+	].filter((v) => v !== null);
+	if (sources.length === 0) return {
+		kind: "error",
+		message: "Pass the verification code as a positional argument or via one of --code-from-stdin, --code-from-file, or --code-from-env."
+	};
+	if (sources.length > 1) return {
+		kind: "error",
+		message: `Pass exactly one source for the verification code; got ${sources.join(", ")}.`
+	};
+	if (input.positional !== void 0) return {
+		kind: "ok",
+		code: input.positional
+	};
+	if (input.fromEnv !== void 0) {
+		const value = (input.env ?? process$1.env)[input.fromEnv];
+		if (value === void 0) return {
+			kind: "error",
+			message: `--code-from-env ${input.fromEnv}: environment variable is not set.`
+		};
+		return {
+			kind: "ok",
+			code: stripTrailingNewline(value)
+		};
+	}
+	if (input.fromFile !== void 0) {
+		const readFile = input.readFile ?? defaultReadCodeFile;
+		try {
+			return {
+				kind: "ok",
+				code: stripTrailingNewline(readFile(input.fromFile))
+			};
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			return {
+				kind: "error",
+				message: `--code-from-file ${input.fromFile}: could not read file: ${detail}`
+			};
+		}
+	}
+	const readStdin = input.readStdin ?? defaultReadCodeStdin;
+	try {
+		return {
+			kind: "ok",
+			code: stripTrailingNewline(readStdin())
+		};
+	} catch (error) {
+		return {
+			kind: "error",
+			message: `--code-from-stdin: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+function stripTrailingNewline(value) {
+	return value.replace(/\r?\n$/, "");
+}
+function defaultReadCodeFile(path) {
+	return readFileSync(path, "utf8");
+}
+function defaultReadCodeStdin() {
+	if (process$1.stdin.isTTY) throw new Error("stdin is a TTY; pipe the code into this command or use --code-from-file / --code-from-env instead.");
+	return readFileSync(0, "utf8");
+}
 var SignupConfirmCommand = class SignupConfirmCommand extends Command {
 	static args = {
 		email: Args.string({
@@ -20949,19 +21017,28 @@ var SignupConfirmCommand = class SignupConfirmCommand extends Command {
 			required: true
 		}),
 		code: Args.string({
-			description: "Verification code from the signup email",
-			required: true
+			description: "Verification code from the signup email. Optional when one of --code-from-stdin / --code-from-file / --code-from-env is passed; exactly one source must be set.",
+			required: false
 		})
 	};
 	static description = "Confirm a pending Primitive signup, create an OAuth session, and save CLI credentials locally.";
 	static summary = "Confirm account signup";
-	static examples = ["<%= config.bin %> signup confirm user@example.com 123456", "<%= config.bin %> signup confirm user@example.com 123456 --org-id 00000000-0000-4000-8000-000000000000"];
+	static examples = [
+		"<%= config.bin %> signup confirm user@example.com 123456",
+		"<%= config.bin %> signup confirm user@example.com 123456 --org-id 00000000-0000-4000-8000-000000000000",
+		"read -rs CODE && CODE=\"$CODE\" <%= config.bin %> signup confirm user@example.com --code-from-env CODE && unset CODE",
+		"read -rs CODE && printf '%s' \"$CODE\" | <%= config.bin %> signup confirm user@example.com --code-from-stdin && unset CODE",
+		"<%= config.bin %> signup confirm user@example.com --code-from-file /run/user/$(id -u)/verification-code"
+	];
 	static flags = {
 		"api-base-url": Flags.string({
 			description: "Override the primary API base URL. Internal testing only; not documented to customers.",
 			env: "PRIMITIVE_API_BASE_URL",
 			hidden: true
 		}),
+		"code-from-stdin": Flags.boolean({ description: "Read the verification code from stdin instead of the positional argument. Use when an agent is constructing the command for the user to run, so the code never enters the agent's prompt context." }),
+		"code-from-file": Flags.string({ description: "Read the verification code from a UTF-8 file at this path. Trailing newlines are stripped." }),
+		"code-from-env": Flags.string({ description: "Read the verification code from this environment variable. Pair with `read -rs CODE && CODE=\"$CODE\" primitive signup confirm <email> --code-from-env CODE && unset CODE` so the value never appears on the command line or in shell history. Plain `read` creates a shell-local variable that child processes cannot see; the inline `CODE=\"$CODE\"` exports it for just the one command." }),
 		force: Flags.boolean({
 			char: "f",
 			description: "Replace saved credentials after verification"
@@ -20970,6 +21047,13 @@ var SignupConfirmCommand = class SignupConfirmCommand extends Command {
 	};
 	async run() {
 		const { args, flags } = await this.parse(SignupConfirmCommand);
+		const resolvedCode = resolveVerificationCode({
+			positional: args.code,
+			fromStdin: flags["code-from-stdin"] === true,
+			fromFile: flags["code-from-file"],
+			fromEnv: flags["code-from-env"]
+		});
+		if (resolvedCode.kind === "error") throw cliError$2(resolvedCode.message);
 		let releaseCredentialsLock;
 		try {
 			releaseCredentialsLock = acquireCliCredentialsLock(this.config.configDir);
@@ -20978,7 +21062,7 @@ var SignupConfirmCommand = class SignupConfirmCommand extends Command {
 		}
 		try {
 			await runSignupConfirmWithCredentialLock({
-				code: args.code,
+				code: resolvedCode.code,
 				configDir: this.config.configDir,
 				email: args.email,
 				flags
@@ -22383,6 +22467,43 @@ function renderFishCompletion(binName) {
 	return `${lines.join("\n")}\n`;
 }
 //#endregion
+//#region src/oclif/shell-completion-script.ts
+/**
+* Path to the sourceable completion *function* file that
+* `@oclif/plugin-autocomplete` writes under the CLI cache dir when its cache is
+* built. This is the artifact a shell is meant to source -- a package manager
+* dropping a file into `bash_completion.d/` or zsh's `site-functions/` wants
+* this, NOT the human-readable setup instructions printed by
+* `<bin> autocomplete <shell>`. The layout mirrors the plugin's own
+* `Create.bashCompletionFunctionPath` / `zshCompletionFunctionPath` getters:
+*   <cacheDir>/autocomplete/functions/bash/<bin>.bash
+*   <cacheDir>/autocomplete/functions/zsh/_<bin>
+*
+* This couples to a private path layout in `@oclif/plugin-autocomplete`
+* (pinned `^3.2.45` in package.json). If a major bump reorganises that cache
+* dir, `readCompletionFunction` will fail even after a successful
+* `--refresh-cache`; re-verify this layout when bumping the plugin.
+*/
+function completionFunctionPath(cacheDir, bin, shell) {
+	const functionsDir = path.join(cacheDir, "autocomplete", "functions", shell);
+	const fileName = shell === "bash" ? `${bin}.bash` : `_${bin}`;
+	return path.join(functionsDir, fileName);
+}
+/**
+* Read the generated completion function script, trimmed of trailing
+* whitespace so the caller can re-add a single newline. Throws an actionable
+* error (rather than a bare `ENOENT`) if the cached script is missing -- e.g.
+* the cache build failed, or the plugin changed its path layout.
+*/
+function readCompletionFunction(cacheDir, bin, shell) {
+	const filePath = completionFunctionPath(cacheDir, bin, shell);
+	try {
+		return readFileSync(filePath, "utf8").trimEnd();
+	} catch (cause) {
+		throw new Error(`Could not read the generated ${shell} completion script at ${filePath}. Run \`${bin} autocomplete ${shell} --refresh-cache\` and try again.`, { cause });
+	}
+}
+//#endregion
 //#region src/oclif/index.ts
 var ListOperationsCommand = class extends Command {
 	static description = "List all generated API operations as JSON. Useful for piping to `jq` to discover available commands, their request/response schemas, and per-field descriptions. For inspecting a single operation in detail, prefer `primitive describe <command-or-operation-name>`.";
@@ -22503,14 +22624,32 @@ var CompletionCommand = class CompletionCommand extends Command {
 		],
 		required: true
 	}) };
-	static description = "Show shell completion output or installation instructions for supported shells";
-	static summary = "Show shell completion output or installation instructions";
+	static description = `Output a sourceable shell completion script, or print setup instructions.
+
+  For fish, and for bash/zsh when the output is piped or redirected (e.g. into a
+  completion file under bash_completion.d or zsh's site-functions), this emits
+  the raw completion script. For bash/zsh in an interactive terminal it prints
+  the human-readable setup instructions instead. This keeps a redirected
+  \`<%= config.bin %> completion bash > <file>\` safe to source -- the file holds an
+  actual completion function, never instructional prose a shell would choke on.`;
+	static summary = "Output a shell completion script or print setup instructions";
+	static examples = [
+		"<%= config.bin %> completion bash >> /etc/bash_completion.d/primitive",
+		"<%= config.bin %> completion zsh > /usr/local/share/zsh/site-functions/_primitive",
+		"<%= config.bin %> completion fish > ~/.config/fish/completions/primitive.fish"
+	];
 	async run() {
 		const { args } = await this.parse(CompletionCommand);
-		if (args.shell === "fish") {
+		const shell = args.shell;
+		if (shell === "fish") {
 			this.log(renderFishCompletion(this.config.bin));
 			return;
 		}
+		if ((shell === "bash" || shell === "zsh") && !process.stdout.isTTY) {
+			await this.config.runCommand("autocomplete", [shell, "--refresh-cache"]);
+			this.log(readCompletionFunction(this.config.cacheDir, this.config.bin, shell));
+			return;
+		}
 		await this.config.runCommand("autocomplete", [args.shell]);
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitivedotdev/cli",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Official Primitive CLI: deploy Primitive Functions, send and inspect mail, manage endpoints, all from the terminal. Wraps the @primitivedotdev/sdk runtime client with one-shot commands.",
   "type": "module",
   "sideEffects": false,