zinkee 0.1.44 → 0.1.46

package/src/commands/files.test.ts

@@ -1,284 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { Command } from "commander";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { registerFilesCommands } from "./files.js";
-
-function createTempConfig(contents: string): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-files-"));
-  const filePath = join(dir, "config.toml");
-  writeFileSync(filePath, contents, "utf8");
-  return filePath;
-}
-
-function createApiConfig(): string {
-  return createTempConfig(`
-default_profile = "prod"
-
-[profiles.prod]
-api_key = "files-token-1234"
-base_url = "https://api.zinkee.test"
-`);
-}
-
-function createStdoutBuffer() {
-  const chunks: Buffer[] = [];
-
-  return {
-    stdout: {
-      write(chunk: string | Uint8Array) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        return true;
-      },
-    },
-    readText() {
-      return Buffer.concat(chunks).toString("utf8");
-    },
-    readBytes() {
-      return Buffer.concat(chunks);
-    },
-  };
-}
-
-function jsonResponse(body: unknown, status: number = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "content-type": "application/json",
-    },
-  });
-}
-
-function binaryResponse(bytes: number[], status: number = 200): Response {
-  return new Response(new Uint8Array(bytes), {
-    status,
-    headers: {
-      "content-type": "application/octet-stream",
-    },
-  });
-}
-
-function createFetchMock() {
-  const fetchMock = vi.fn<typeof fetch>();
-  vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-function createProgram(): Command {
-  return new Command()
-    .enablePositionalOptions()
-    .option("--profile <name>", "select a profile from config")
-    .option("--base-url <url>", "override the configured base URL")
-    .option("--api-key <token>", "override the configured API key")
-    .option("--read-only", "run in read-only mode")
-    .option("--json", "emit JSON output");
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-describe("files commands", () => {
-  it("registers the files command group", () => {
-    const program = createProgram();
-    registerFilesCommands(program);
-
-    expect(program.commands.some((command) => command.name() === "files")).toBe(true);
-  });
-
-  it("uploads a local file through multipart form data", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const filePath = join(mkdtempSync(join(tmpdir(), "zinkee-files-upload-")), "upload.txt");
-    writeFileSync(filePath, "hello world", "utf8");
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        id: "file-1",
-        name: "upload.txt",
-      }),
-    );
-    const program = createProgram();
-    registerFilesCommands(program, { configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "files",
-      "upload",
-      filePath,
-    ]);
-
-    const init = fetchMock.mock.calls[0]?.[1];
-    const body = init?.body as FormData;
-    const file = body.get("file");
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/files");
-    expect(init?.method).toBe("POST");
-    expect(file).not.toBeNull();
-    expect(file).toBeInstanceOf(File);
-    if (!(file instanceof File)) {
-      throw new Error("Expected the upload payload to be a File.");
-    }
-
-    expect(file.name).toBe("upload.txt");
-    expect(Buffer.from(await file.arrayBuffer()).toString("utf8")).toBe("hello world");
-    expect(JSON.parse(output.readText())).toEqual({
-      data: {
-        id: "file-1",
-        name: "upload.txt",
-      },
-      meta: {
-        command: "files upload",
-        configPath,
-      },
-    });
-  });
-
-  it("downloads files to stdout when no output path is provided", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(binaryResponse([104, 101, 108, 108, 111]));
-    const program = createProgram();
-    registerFilesCommands(program, { configPath, stdout: output.stdout });
-
-    await program.parseAsync(["node", "zinkee", "files", "download", "550E8400-E29B-41D4-A716-446655440001"]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe(
-      "https://api.zinkee.test/api/v2/files/550e8400-e29b-41d4-a716-446655440001",
-    );
-    expect(output.readBytes().equals(Buffer.from("hello"))).toBe(true);
-  });
-
-  it("fails when json output is requested without --output for downloads", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = createProgram();
-    registerFilesCommands(program, { configPath });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--json",
-        "files",
-        "download",
-        "550E8400-E29B-41D4-A716-446655440001",
-      ]),
-    ).rejects.toThrowError('Provide "--output" when using "--json" with "files download".');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("downloads to a file and emits structured metadata in json mode", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    const tempDir = mkdtempSync(join(tmpdir(), "zinkee-files-download-"));
-    const outputPath = join(tempDir, "downloaded.bin");
-    fetchMock.mockResolvedValueOnce(binaryResponse([1, 2, 3]));
-    const program = createProgram();
-    registerFilesCommands(program, { configPath, stdout: output.stdout });
-
-    await program.parseAsync([
-      "node",
-      "zinkee",
-      "--json",
-      "files",
-      "download",
-      "550E8400-E29B-41D4-A716-446655440001",
-      "--output",
-      outputPath,
-    ]);
-
-    expect(readFileSync(outputPath)).toEqual(Buffer.from([1, 2, 3]));
-    expect(JSON.parse(output.readText())).toEqual({
-      data: {
-        file: "550e8400-e29b-41d4-a716-446655440001",
-        output: outputPath,
-        bytes: 3,
-      },
-      meta: {
-        command: "files download",
-        configPath,
-      },
-    });
-  });
-
-  it("blocks file deletion in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const program = createProgram();
-    registerFilesCommands(program, { configPath });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "files",
-        "delete",
-        "550E8400-E29B-41D4-A716-446655440001",
-      ]),
-    ).rejects.toThrowError('Command "files delete" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("blocks file uploads in read-only mode", async () => {
-    const configPath = createApiConfig();
-    const fetchMock = createFetchMock();
-    const tempDir = mkdtempSync(join(tmpdir(), "zinkee-files-upload-ro-"));
-    const filePath = join(tempDir, "upload.txt");
-    writeFileSync(filePath, "hello world", "utf8");
-    const program = createProgram();
-    registerFilesCommands(program, { configPath });
-
-    await expect(
-      program.parseAsync([
-        "node",
-        "zinkee",
-        "--read-only",
-        "files",
-        "upload",
-        filePath,
-      ]),
-    ).rejects.toThrowError('Command "files upload" is not allowed in read-only mode.');
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("requests file storage information", async () => {
-    const configPath = createApiConfig();
-    const output = createStdoutBuffer();
-    const fetchMock = createFetchMock();
-    fetchMock.mockResolvedValueOnce(
-      jsonResponse({
-        usedBytes: 10,
-        totalBytes: 100,
-      }),
-    );
-    const program = createProgram();
-    registerFilesCommands(program, { configPath, stdout: output.stdout });
-
-    await program.parseAsync(["node", "zinkee", "--json", "files", "storage"]);
-
-    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.zinkee.test/api/v2/files/storage-info");
-    expect(JSON.parse(output.readText())).toEqual({
-      data: {
-        usedBytes: 10,
-        totalBytes: 100,
-      },
-      meta: {
-        command: "files storage",
-        configPath,
-      },
-    });
-  });
-});

package/src/commands/files.ts

@@ -1,280 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { basename } from "node:path";
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import { FilesApi } from "../api/files.js";
-import { ApiClient } from "../client.js";
-import { defaultConfigPath, readRuntimeConfig } from "../config.js";
-import { normalizeUuidOrSlug, type NormalizedUuidOrSlug } from "../parsers/selectors.js";
-import { resolveRuntimeContext } from "../runtime-context.js";
-import type { JsonObject, RuntimeOverrides } from "../types.js";
-import { CliError } from "../utils/errors.js";
-import { buildJsonSuccess, printTable } from "../utils/output.js";
-
-interface CommandIo {
-  write(chunk: string | Uint8Array): unknown;
-}
-
-export interface RegisterFilesCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-interface FilesDownloadCommandOptions {
-  output?: string;
-}
-
-function getCommandIo(stdout: CommandIo | undefined): CommandIo {
-  return stdout ?? (process.stdout as Writable);
-}
-
-function writeLine(stdout: CommandIo, value: string): void {
-  stdout.write(`${value}\n`);
-}
-
-function writeBinary(stdout: CommandIo, value: ArrayBuffer): void {
-  stdout.write(Buffer.from(value));
-}
-
-function getGlobalOptions(command: Command): GlobalOptions {
-  return command.optsWithGlobals<GlobalOptions>();
-}
-
-function emitJson(
-  stdout: CommandIo,
-  commandName: string,
-  data: unknown,
-  configPath: string,
-  meta: Record<string, unknown> = {},
-): void {
-  writeLine(
-    stdout,
-    JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath, ...meta })),
-  );
-}
-
-function toConfigurationError(filePath: string, error: unknown): never {
-  if (error instanceof CliError) {
-    throw error;
-  }
-
-  if (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    error.code === "ENOENT"
-  ) {
-    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
-  }
-
-  if (error instanceof Error) {
-    throw new CliError("configuration_error", error.message);
-  }
-
-  throw error;
-}
-
-function createFilesApi(
-  command: Command,
-  filePath: string,
-): { api: FilesApi; json: boolean; readOnly: boolean } {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions(command));
-
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`,
-      );
-    }
-
-    return {
-      api: new FilesApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey,
-        }),
-      ),
-      json: runtime.json,
-      readOnly: runtime.readOnly,
-    };
-  } catch (error) {
-    toConfigurationError(filePath, error);
-  }
-}
-
-function ensureWritable(
-  commandName: string,
-  readOnly: boolean,
-  commandMode: "write" | "destructive",
-): void {
-  if (readOnly) {
-    throw new CliError(
-      "command_not_allowed_in_read_only_mode",
-      `Command "${commandName}" is not allowed in read-only mode.`,
-      {
-        commandMode,
-        executionMode: "read-only",
-      },
-    );
-  }
-}
-
-function parseUuidOrSlugSelector(input: string): NormalizedUuidOrSlug {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError(message);
-  }
-}
-
-function isRecord(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readLocalFile(filePath: string): Buffer {
-  try {
-    return readFileSync(filePath);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unable to read file.";
-    throw new CliError("invalid_cli_usage", `Failed to read file at ${filePath}: ${message}`);
-  }
-}
-
-function writeDownloadedFile(outputPath: string, value: ArrayBuffer): void {
-  try {
-    writeFileSync(outputPath, Buffer.from(value));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unable to write file.";
-    throw new CliError(
-      "invalid_cli_usage",
-      `Failed to write downloaded file to ${outputPath}: ${message}`,
-    );
-  }
-}
-
-export function registerFilesCommands(
-  program: Command,
-  options: RegisterFilesCommandsOptions = {},
-): void {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-
-  const files = program.command("files").description("Manage files and storage");
-
-  files
-    .command("upload")
-    .description("Upload a local file")
-    .argument("<path>", "path to the local file")
-    .action(function action(this: Command, path: string) {
-      const { api, json, readOnly } = createFilesApi(this, filePath);
-      ensureWritable("files upload", readOnly, "write");
-
-      const contents = readLocalFile(path);
-      const formData = new FormData();
-      formData.append("file", new Blob([contents]), basename(path));
-
-      return api.uploadFile(formData).then((data) => {
-        if (json) {
-          emitJson(stdout, "files upload", data, filePath);
-          return;
-        }
-
-        writeLine(stdout, `Uploaded file "${basename(path)}".`);
-      });
-    });
-
-  files
-    .command("download")
-    .description("Download a file")
-    .argument("<file>", "file identifier")
-    .option("--output <path>", "write the downloaded file to a path")
-    .action(function action(
-      this: Command,
-      file: string,
-      commandOptions: FilesDownloadCommandOptions,
-    ) {
-      const { api, json } = createFilesApi(this, filePath);
-
-      if (json && !commandOptions.output) {
-        throw new CliError(
-          "invalid_cli_usage",
-          'Provide "--output" when using "--json" with "files download".',
-        );
-      }
-
-      const fileSelector = parseUuidOrSlugSelector(file);
-
-      return api.downloadFile(fileSelector).then((data) => {
-        if (commandOptions.output) {
-          writeDownloadedFile(commandOptions.output, data);
-
-          if (json) {
-            emitJson(
-              stdout,
-              "files download",
-              {
-                file: fileSelector.value,
-                output: commandOptions.output,
-                bytes: data.byteLength,
-              },
-              filePath,
-            );
-            return;
-          }
-
-          writeLine(stdout, `Downloaded file to "${commandOptions.output}".`);
-          return;
-        }
-
-        writeBinary(stdout, data);
-      });
-    });
-
-  files
-    .command("delete")
-    .description("Delete a file")
-    .argument("<file>", "file identifier")
-    .action(function action(this: Command, file: string) {
-      const { api, json, readOnly } = createFilesApi(this, filePath);
-      ensureWritable("files delete", readOnly, "destructive");
-
-      const fileSelector = parseUuidOrSlugSelector(file);
-
-      return api.deleteFile(fileSelector).then((data) => {
-        if (json) {
-          emitJson(stdout, "files delete", data, filePath);
-          return;
-        }
-
-        writeLine(stdout, `Deleted file "${fileSelector.value}".`);
-      });
-    });
-
-  files
-    .command("storage")
-    .description("Show storage usage information")
-    .action(function action(this: Command) {
-      const { api, json } = createFilesApi(this, filePath);
-
-      return api.getStorageInfo().then((data) => {
-        if (json) {
-          emitJson(stdout, "files storage", data, filePath);
-          return;
-        }
-
-        if (isRecord(data)) {
-          printTable([data], Object.keys(data), stdout);
-          return;
-        }
-
-        writeLine(stdout, String(data));
-      });
-    });
-}