feat: print pre-signed upload URL when invoked with 0 paths

When `rli object upload --name <name>` is called without any file paths,
create the object via the API and print the pre-signed upload URL to
stdout. This enables external upload workflows (e.g. curl) matching the
frontend's "Copy URL and Close" pattern. The object stays in UPLOADING
state until the user uploads and completes externally.

- Change `<paths...>` to `[paths...]` (Commander optional variadic)
- Skip interactive screen buffer for 0-paths mode
- Default content type to "unspecified" when omitted
- Add null guard for upload_url from API response

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jason-rl

README.md

@@ -148,7 +148,7 @@ rli blueprint from-dockerfile            # Create a blueprint from a Dockerfile
 rli object list                          # List objects
 rli object get <id>                      # Get object details
 rli object download <id> [path]          # Download object to local file (path d...
-rli object upload <paths...>             # Upload file(s) or directory as an obj...
+rli object upload [paths...]             # Upload file(s) or directory as an obj...
 rli object delete <id>                   # Delete an object (irreversible)
 ```
 

src/commands/object/upload.ts

@@ -175,7 +175,33 @@ export async function uploadObject(options: UploadObjectOptions) {
     const { paths, name, contentType, output: outputFormat } = options;
 
     if (paths.length === 0) {
-      outputError("At least one path is required");
+      if (!name) {
+        outputError("--name is required when no paths are provided");
+      }
+      const resolvedContentType: ContentType =
+        (contentType as ContentType) || "unspecified";
+
+      const createResponse = await client.objects.create({
+        name,
+        content_type: resolvedContentType,
+      });
+
+      if (!createResponse.upload_url) {
+        outputError("API did not return an upload URL");
+      }
+
+      const result = {
+        id: createResponse.id,
+        name,
+        contentType: resolvedContentType,
+        uploadUrl: createResponse.upload_url,
+      };
+
+      if (!outputFormat || outputFormat === "text") {
+        console.log(createResponse.upload_url);
+      } else {
+        output(result, { format: outputFormat, defaultFormat: "json" });
+      }
       return;
     }
 

src/utils/commands.ts

@@ -650,11 +650,11 @@ export function createProgram(): Command {
     });
 
   object
-    .command("upload <paths...>")
+    .command("upload [paths...]")
     .description(
-      "Upload file(s) or directory as an object. Multiple paths with --content-type tar|tgz creates an archive. Use - to read from stdin.",
+      "Upload file(s) or directory as an object. With no paths, creates the object and prints the upload URL. Use - to read from stdin.",
     )
-    .option("--name <name>", "Object name (required; mandatory for stdin)")
+    .option("--name <name>", "Object name (required)")
     .option(
       "--content-type <type>",
       "Content type: unspecified|text|binary|gzip|tar|tgz",
@@ -666,12 +666,15 @@ export function createProgram(): Command {
     )
     .action(async (paths, options) => {
       const { uploadObject } = await import("../commands/object/upload.js");
-      if (!options.output) {
+      const resolvedPaths = paths || [];
+      if (!options.output && resolvedPaths.length > 0) {
         const { runInteractiveCommand } =
           await import("../utils/interactiveCommand.js");
-        await runInteractiveCommand(() => uploadObject({ paths, ...options }));
+        await runInteractiveCommand(() =>
+          uploadObject({ paths: resolvedPaths, ...options }),
+        );
       } else {
-        await uploadObject({ paths, ...options });
+        await uploadObject({ paths: resolvedPaths, ...options });
       }
     });
 

tests/__tests__/commands/object/upload.test.ts

@@ -327,4 +327,90 @@ describe("uploadObject", () => {
     const body = fetchCall[1]?.body as Buffer;
     expect(body.toString()).toBe("fake tar content");
   });
+
+  describe("0-paths mode (URL-only)", () => {
+    it("creates object and prints upload URL when no paths provided", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+      const { uploadObject } = await import("@/commands/object/upload.js");
+      await uploadObject({
+        paths: [],
+        name: "url-only-object",
+        contentType: "text",
+      });
+
+      expect(mockCreate).toHaveBeenCalledWith({
+        name: "url-only-object",
+        content_type: "text",
+      });
+      expect(logSpy).toHaveBeenCalledWith("https://example.com/upload");
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(mockComplete).not.toHaveBeenCalled();
+      logSpy.mockRestore();
+    });
+
+    it("defaults content type to unspecified when omitted", async () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+      const { uploadObject } = await import("@/commands/object/upload.js");
+      await uploadObject({
+        paths: [],
+        name: "no-ct-object",
+      });
+
+      expect(mockCreate).toHaveBeenCalledWith({
+        name: "no-ct-object",
+        content_type: "unspecified",
+      });
+      expect(logSpy).toHaveBeenCalledWith("https://example.com/upload");
+      logSpy.mockRestore();
+    });
+
+    it("outputs structured result in JSON mode", async () => {
+      const { uploadObject } = await import("@/commands/object/upload.js");
+      await uploadObject({
+        paths: [],
+        name: "json-url-object",
+        contentType: "binary",
+        output: "json",
+      });
+
+      expect(mockOutput).toHaveBeenCalledWith(
+        {
+          id: "obj_test123",
+          name: "json-url-object",
+          contentType: "binary",
+          uploadUrl: "https://example.com/upload",
+        },
+        { format: "json", defaultFormat: "json" },
+      );
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(mockComplete).not.toHaveBeenCalled();
+    });
+
+    it("errors when --name is missing", async () => {
+      mockOutputError.mockImplementationOnce(() => {
+        throw new Error("exit");
+      });
+      mockOutputError.mockImplementationOnce(() => {
+        throw new Error("exit");
+      });
+
+      const { uploadObject } = await import("@/commands/object/upload.js");
+      try {
+        await uploadObject({
+          paths: [],
+          name: "",
+        });
+      } catch {
+        // expected: mockOutputError throws to simulate process.exit
+      }
+
+      expect(mockOutputError).toHaveBeenNthCalledWith(
+        1,
+        "--name is required when no paths are provided",
+      );
+      expect(mockCreate).not.toHaveBeenCalled();
+    });
+  });
 });