@supercycle/cli 0.1.0

package/README.md

@@ -0,0 +1,107 @@
+# Supercycle CLI
+
+A command-line interface for the [Supercycle Admin API](https://docs.supercycle.com/api-reference/admin/introduction), built with Node and [Ink](https://github.com/vadimdemedes/ink).
+
+> In the Supercycle UI a **cycle** is modelled as a **rental** in the API. This CLI uses the "cycle" terminology.
+
+## Requirements
+
+- Node.js ≥ 18
+- A Supercycle Admin API key (Superest or custom plans — created in Supercycle → Settings → API)
+
+## Install
+
+```sh
+pnpm install
+pnpm build
+pnpm link --global   # optional: makes `supercycle` available globally
+```
+
+During development, run commands with `node dist/cli.js …` (rebuild with `pnpm build`, or `pnpm dev` to watch).
+
+Code quality:
+
+```sh
+pnpm fmt          # format with oxfmt
+pnpm fmt:check    # verify formatting (CI)
+pnpm lint         # lint with oxlint
+pnpm lint:fix     # lint and auto-fix
+```
+
+## Authentication
+
+```sh
+supercycle login              # prompts for your API key, validates, and stores it
+supercycle login --key sk_…   # non-interactive
+```
+
+The key is stored in `~/.config/supercycle/config.json` (mode `600`). You can
+override it with the `SUPERCYCLE_API_KEY` environment variable.
+
+## Usage
+
+List cycles, with optional filters:
+
+```sh
+supercycle cycles list
+supercycle cycles list --fulfillment overdue
+supercycle cycles list --search "jane" --limit 20
+supercycle cycles list --rental-start-from 2024-01-01 --rental-start-to 2024-01-31
+supercycle cycles list --updated-since 2024-06-01    # incremental sync
+supercycle cycles list --page <cursor>               # next page (cursor from previous output)
+supercycle cycles list --all                         # auto-follow every page
+supercycle cycles list --json | jq '.data | length'
+```
+
+Retrieve a single cycle:
+
+```sh
+supercycle cycles get 12345
+supercycle cycles get 12345 --include item,timelineEvents
+supercycle cycles get 12345 --json
+```
+
+### Read shortcuts
+
+Pre-filtered views (each accepts `--search`, `--limit`, `--page`, `--all`, `--json`):
+
+```sh
+supercycle cycles to-fulfill          # awaiting dispatch (unfulfilled)
+supercycle cycles to-receive          # awaiting return (receival due)
+supercycle cycles overdue             # overdue returns (--type fulfillment for dispatches)
+supercycle cycles today               # scheduled to be received back today
+```
+
+### Managing cycles (writes)
+
+> These update Supercycle only — they do **not** change the linked Shopify order/fulfilment.
+> Most print the updated cycle; add `--json` for raw output.
+
+```sh
+supercycle cycles fulfil 12345                    # mark dispatched (now); --at <iso> to backdate
+supercycle cycles receive 12345                   # mark received back; --at <iso>
+supercycle cycles pack 12345 --status packed      # pending|printed|packed
+supercycle cycles reschedule 12345 --fulfill-at 2024-07-01T09:00:00Z --receive-at 2024-07-10T17:00:00Z
+supercycle cycles reassign 12345 --item-id 678 --reallocate
+supercycle cycles tag 12345 --add "vip,priority" --remove "draft"
+supercycle cycles return 12345 --status awaiting --method collection --collection-date 2024-07-05
+```
+
+### List filters
+
+All `GET /rentals` filters are exposed:
+
+- `--search` — title / customer text
+- `--fulfillment`, `--receival` — `due|scheduled|overdue|complete`
+- `--unfulfilled`, `--exclude-cancelled` — booleans
+- `--customer-id`, `--item-id` — numeric
+- `--shopify-order-id`, `--shopify-variant-id`, `--shopify-line-item-id`
+- `--return-order-status` — comma-separated (`requested,expected,received,in_progress,completed,cancelled`)
+- Date ranges (`--*-from` → `gte`, `--*-to` → `lte`, inclusive, ISO dates):
+  `--rental-start-from/-to`, `--created-from/-to`, `--receive-from/-to`,
+  and `--updated-since` (gte, for incremental sync) / `--updated-to`
+- `--include` — relations to include (e.g. `item`)
+- `--limit` (1–100, default 50), `--page <cursor>`, `--json`
+
+Pagination is keyset-based: when more results exist, the output prints a
+`--page <cursor>` hint to fetch the next page.

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import Pastel from "pastel";
+const app = new Pastel({
+    importMeta: import.meta,
+    name: "supercycle",
+    version: "0.1.0",
+    description: "Command-line interface for the Supercycle Admin API",
+});
+await app.run();

package/dist/commands/comments/delete.js

@@ -0,0 +1,48 @@
+import { Text } from "ink";
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import ErrorMessage from "../../components/ErrorMessage.js";
+import ExitError from "../../components/ExitError.js";
+import JsonOutput from "../../components/JsonOutput.js";
+import Loading from "../../components/Loading.js";
+import { useAsync } from "../../hooks/useAsync.js";
+import { resolveClient, NO_TOKEN_HINT } from "../../lib/resolveClient.js";
+export const description = "Delete a timeline comment by ID";
+export const args = zod.tuple([
+    zod.string().describe(argument({
+        name: "id",
+        description: "Numeric ID of the timeline comment (from a resource's timeline events)",
+    })),
+]);
+export const options = zod.object({
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Delete({ args, options }) {
+    const [id] = args;
+    const resolved = resolveClient();
+    const state = useAsync(async () => {
+        if (!resolved.client)
+            throw new Error(resolved.error);
+        await resolved.client.deleteTimelineComment(id);
+        return { id, deleted: true };
+    }, []);
+    if (state.loading) {
+        return options.json ? null : React.createElement(Loading, { label: `Deleting comment ${id}…` });
+    }
+    if (state.error) {
+        if (options.json)
+            return React.createElement(ExitError, { message: state.error.message });
+        return (React.createElement(ErrorMessage, { message: state.error.message, hint: resolved.error ? NO_TOKEN_HINT : undefined }));
+    }
+    if (options.json) {
+        return React.createElement(JsonOutput, { data: state.data });
+    }
+    return React.createElement(Text, { color: "green" },
+        "\u2714 Comment ",
+        id,
+        " deleted");
+}

package/dist/commands/comments/index.js

@@ -0,0 +1,3 @@
+// Group landing: description only (no default export) so Pastel falls through
+// to Commander's auto-generated help listing the subcommands.
+export const description = "Manage timeline comments";

package/dist/commands/conditions/index.js

@@ -0,0 +1,3 @@
+// Group landing: description only (no default export) so Pastel falls through
+// to Commander's auto-generated help listing the subcommands.
+export const description = "List item conditions";

package/dist/commands/conditions/list.js

@@ -0,0 +1,20 @@
+import { option } from "pastel";
+import React from "react";
+import zod from "zod";
+import ReferenceListView from "../../components/ReferenceListView.js";
+import { dash, titleCase } from "../../lib/format.js";
+export const description = "List all conditions";
+const COLUMNS = [
+    { label: "ID", width: 8, value: (c) => dash(c.id) },
+    { label: "Condition", width: 28, value: (c) => dash(c.title) },
+    { label: "Severity", value: (c) => titleCase(c.severityKey) },
+];
+export const options = zod.object({
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function List({ options }) {
+    return (React.createElement(ReferenceListView, { fetch: (client) => client.listConditions(), columns: COLUMNS, rowKey: (c) => c.id, loadingLabel: "Fetching conditions\u2026", emptyLabel: "No conditions found.", noun: "condition", json: options.json }));
+}

package/dist/commands/custom-fields/definition.js

@@ -0,0 +1,58 @@
+import { Box, Text } from "ink";
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import ErrorMessage from "../../components/ErrorMessage.js";
+import ExitError from "../../components/ExitError.js";
+import JsonOutput from "../../components/JsonOutput.js";
+import Loading from "../../components/Loading.js";
+import { useAsync } from "../../hooks/useAsync.js";
+import { dash, titleCase } from "../../lib/format.js";
+import { resolveClient, NO_TOKEN_HINT } from "../../lib/resolveClient.js";
+export const description = "Retrieve a single custom field definition by ID";
+export const args = zod.tuple([
+    zod.string().describe(argument({
+        name: "id",
+        description: "Numeric ID of the custom field definition",
+    })),
+]);
+export const options = zod.object({
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+function Field({ label, children }) {
+    return (React.createElement(Box, null,
+        React.createElement(Box, { width: 18 },
+            React.createElement(Text, { dimColor: true }, label)),
+        React.createElement(Text, null, children)));
+}
+export default function Definition({ args, options }) {
+    const [id] = args;
+    const resolved = resolveClient();
+    const state = useAsync(async () => {
+        if (!resolved.client)
+            throw new Error(resolved.error);
+        return resolved.client.getCustomFieldDefinition(id);
+    }, []);
+    if (state.loading) {
+        return options.json ? null : React.createElement(Loading, { label: `Fetching definition ${id}…` });
+    }
+    if (state.error) {
+        if (options.json)
+            return React.createElement(ExitError, { message: state.error.message });
+        return (React.createElement(ErrorMessage, { message: state.error.message, hint: resolved.error ? NO_TOKEN_HINT : undefined }));
+    }
+    if (options.json) {
+        return React.createElement(JsonOutput, { data: state.data });
+    }
+    const def = state.data;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true, underline: true }, def.name),
+        React.createElement(Field, { label: "ID" }, String(def.id)),
+        React.createElement(Field, { label: "Key" }, dash(def.key)),
+        React.createElement(Field, { label: "Owner type" }, titleCase(def.ownerType)),
+        React.createElement(Field, { label: "Value type" }, titleCase(def.type)),
+        React.createElement(Field, { label: "Groups fulfil." }, def.groupFulfillments ? "yes" : "no")));
+}

package/dist/commands/custom-fields/definitions.js

@@ -0,0 +1,25 @@
+import { option } from "pastel";
+import React from "react";
+import zod from "zod";
+import ReferenceListView from "../../components/ReferenceListView.js";
+import { dash, titleCase } from "../../lib/format.js";
+export const description = "List custom field definitions for an owner type";
+const COLUMNS = [
+    { label: "ID", width: 8, value: (d) => dash(d.id) },
+    { label: "Key", width: 24, value: (d) => dash(d.key) },
+    { label: "Name", width: 24, value: (d) => dash(d.name) },
+    { label: "Type", width: 22, value: (d) => titleCase(d.type) },
+    { label: "Group", value: (d) => (d.groupFulfillments ? "yes" : "no") },
+];
+export const options = zod.object({
+    ownerType: zod
+        .enum(["item", "rental"])
+        .describe(option({ description: "Owner type: item|rental (required)" })),
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Definitions({ options }) {
+    return (React.createElement(ReferenceListView, { fetch: (client) => client.listCustomFieldDefinitions({ ownerType: options.ownerType }), columns: COLUMNS, rowKey: (d) => d.id, loadingLabel: `Fetching ${options.ownerType} custom field definitions…`, emptyLabel: "No custom field definitions found.", noun: "definition", json: options.json }));
+}

package/dist/commands/custom-fields/delete.js

@@ -0,0 +1,45 @@
+import { Text } from "ink";
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import ErrorMessage from "../../components/ErrorMessage.js";
+import ExitError from "../../components/ExitError.js";
+import JsonOutput from "../../components/JsonOutput.js";
+import Loading from "../../components/Loading.js";
+import { useAsync } from "../../hooks/useAsync.js";
+import { resolveClient, NO_TOKEN_HINT } from "../../lib/resolveClient.js";
+export const description = "Delete a custom field by ID";
+export const args = zod.tuple([
+    zod.string().describe(argument({ name: "id", description: "Numeric custom field ID" })),
+]);
+export const options = zod.object({
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Delete({ args, options }) {
+    const [id] = args;
+    const resolved = resolveClient();
+    const state = useAsync(async () => {
+        if (!resolved.client)
+            throw new Error(resolved.error);
+        await resolved.client.deleteCustomField(id);
+        return { id, deleted: true };
+    }, []);
+    if (state.loading) {
+        return options.json ? null : React.createElement(Loading, { label: `Deleting custom field ${id}…` });
+    }
+    if (state.error) {
+        if (options.json)
+            return React.createElement(ExitError, { message: state.error.message });
+        return (React.createElement(ErrorMessage, { message: state.error.message, hint: resolved.error ? NO_TOKEN_HINT : undefined }));
+    }
+    if (options.json) {
+        return React.createElement(JsonOutput, { data: state.data });
+    }
+    return React.createElement(Text, { color: "green" },
+        "\u2714 Custom field ",
+        id,
+        " deleted");
+}

package/dist/commands/custom-fields/index.js

@@ -0,0 +1,3 @@
+// Group landing: description only (no default export) so Pastel falls through
+// to Commander's auto-generated help listing the subcommands.
+export const description = "Inspect and manage custom fields";

package/dist/commands/custom-fields/set.js

@@ -0,0 +1,43 @@
+import { option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CustomFieldResultView from "../../components/CustomFieldResultView.js";
+import ErrorMessage from "../../components/ErrorMessage.js";
+export const description = "Set a custom field value on an item or rental";
+export const options = zod.object({
+    ownerId: zod
+        .number()
+        .describe(option({ description: "ID of the item or rental to attach the field to (required)" })),
+    value: zod.string().describe(option({ description: "Value to store (required)" })),
+    definitionId: zod
+        .number()
+        .optional()
+        .describe(option({ description: "Custom field definition ID (or use --key + --owner-type)" })),
+    key: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Definition key (requires --owner-type)" })),
+    ownerType: zod
+        .enum(["item", "rental"])
+        .optional()
+        .describe(option({ description: "Owner type: item|rental (requires --key)" })),
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Set({ options }) {
+    const hasDefinition = options.definitionId != null;
+    const hasKeyPair = Boolean(options.key && options.ownerType);
+    if (!hasDefinition && !hasKeyPair) {
+        return (React.createElement(ErrorMessage, { message: "Specify the definition with --definition-id, or with --key and --owner-type." }));
+    }
+    const body = {
+        ownerId: options.ownerId,
+        value: options.value,
+        definitionId: options.definitionId,
+        key: hasDefinition ? undefined : options.key,
+        ownerType: hasDefinition ? undefined : options.ownerType,
+    };
+    return (React.createElement(CustomFieldResultView, { loadingLabel: `Setting custom field on ${options.ownerType ?? "owner"} ${options.ownerId}…`, action: (client) => client.createCustomField(body), successLabel: (f) => `Custom field "${f.key}" set`, json: options.json }));
+}

package/dist/commands/custom-fields/update.js

@@ -0,0 +1,19 @@
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CustomFieldResultView from "../../components/CustomFieldResultView.js";
+export const description = "Update an existing custom field's value";
+export const args = zod.tuple([
+    zod.string().describe(argument({ name: "id", description: "Numeric custom field ID" })),
+]);
+export const options = zod.object({
+    value: zod.string().describe(option({ description: "New value to store (required)" })),
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Update({ args, options }) {
+    const [id] = args;
+    return (React.createElement(CustomFieldResultView, { loadingLabel: `Updating custom field ${id}…`, action: (client) => client.updateCustomField(id, options.value), successLabel: (f) => `Custom field "${f.key}" updated`, json: options.json }));
+}

package/dist/commands/cycles/comment.js

@@ -0,0 +1,29 @@
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CommentResultView from "../../components/CommentResultView.js";
+import ErrorMessage from "../../components/ErrorMessage.js";
+export const description = "Add a comment to a cycle's timeline";
+export const args = zod.tuple([
+    zod.string().describe(argument({ name: "id", description: "Numeric cycle ID" })),
+    zod.string().describe(argument({ name: "message", description: "Comment text" })),
+]);
+export const options = zod.object({
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Comment({ args, options }) {
+    const [id, message] = args;
+    if (!message.trim()) {
+        return React.createElement(ErrorMessage, { message: "Comment message cannot be empty." });
+    }
+    return (React.createElement(CommentResultView, { loadingLabel: `Adding comment to cycle ${id}…`, action: (client) => client.createTimelineComment({
+            timelineEvent: {
+                eventableId: Number(id),
+                eventableType: "Rental",
+                message,
+            },
+        }), json: options.json }));
+}

package/dist/commands/cycles/fulfil.js

@@ -0,0 +1,24 @@
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CycleActionView from "../../components/CycleActionView.js";
+export const description = "Mark a cycle as fulfilled (dispatched)";
+export const args = zod.tuple([
+    zod.string().describe(argument({ name: "id", description: "Numeric cycle ID" })),
+]);
+export const options = zod.object({
+    at: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Dispatch time (ISO date-time; defaults to now)" })),
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+// Note: this updates Supercycle only — it does not fulfil the Shopify order.
+export default function Fulfil({ args, options }) {
+    const [id] = args;
+    const fulfilledAt = options.at ?? new Date().toISOString();
+    return (React.createElement(CycleActionView, { loadingLabel: `Fulfilling cycle ${id}…`, action: (client) => client.updateCycle(id, { fulfilledAt }), successLabel: (c) => `Cycle ${c.id} marked as fulfilled`, json: options.json }));
+}

package/dist/commands/cycles/get.js

@@ -0,0 +1,50 @@
+import { argument, option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CycleDetail from "../../components/CycleDetail.js";
+import ErrorMessage from "../../components/ErrorMessage.js";
+import ExitError from "../../components/ExitError.js";
+import JsonOutput from "../../components/JsonOutput.js";
+import Loading from "../../components/Loading.js";
+import { useAsync } from "../../hooks/useAsync.js";
+import { resolveClient, NO_TOKEN_HINT } from "../../lib/resolveClient.js";
+export const description = "Retrieve a single cycle by ID";
+export const args = zod.tuple([
+    zod.string().describe(argument({
+        name: "id",
+        description: "Numeric ID of the cycle",
+    })),
+]);
+export const options = zod.object({
+    include: zod
+        .string()
+        .optional()
+        .describe(option({
+        description: "Relations to include, e.g. item,timelineEvents",
+    })),
+    json: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Output raw JSON" })),
+});
+export default function Get({ args, options }) {
+    const [id] = args;
+    const resolved = resolveClient();
+    const state = useAsync(async () => {
+        if (!resolved.client)
+            throw new Error(resolved.error);
+        return resolved.client.getCycle(id, { include: options.include });
+    }, []);
+    if (state.loading) {
+        return options.json ? null : React.createElement(Loading, { label: `Fetching cycle ${id}…` });
+    }
+    if (state.error) {
+        if (options.json)
+            return React.createElement(ExitError, { message: state.error.message });
+        return (React.createElement(ErrorMessage, { message: state.error.message, hint: resolved.error ? NO_TOKEN_HINT : undefined }));
+    }
+    if (options.json) {
+        return React.createElement(JsonOutput, { data: state.data });
+    }
+    return React.createElement(CycleDetail, { cycle: state.data });
+}

package/dist/commands/cycles/index.js

@@ -0,0 +1,3 @@
+// Group landing: description only (no default export) so Pastel falls through
+// to Commander's auto-generated help listing the subcommands.
+export const description = "List, inspect, and manage cycles";

package/dist/commands/cycles/list.js

@@ -0,0 +1,124 @@
+import { option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CyclesListView from "../../components/CyclesListView.js";
+import { listViewShape, viewFilters } from "../../lib/listViewOptions.js";
+export const description = "List cycles, optionally filtered";
+const progress = zod.enum(["due", "scheduled", "overdue", "complete"]);
+export const options = zod.object({
+    ...listViewShape(),
+    fulfillment: progress
+        .optional()
+        .describe(option({ description: "Fulfillment status: due|scheduled|overdue|complete" })),
+    receival: progress
+        .optional()
+        .describe(option({ description: "Receival status: due|scheduled|overdue|complete" })),
+    unfulfilled: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Only show unfulfilled cycles" })),
+    excludeCancelled: zod
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Omit cancelled cycles" })),
+    customerId: zod
+        .number()
+        .optional()
+        .describe(option({ description: "Filter by customer ID" })),
+    itemId: zod
+        .number()
+        .optional()
+        .describe(option({ description: "Filter by item ID" })),
+    shopifyOrderId: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Filter by Shopify order ID" })),
+    shopifyVariantId: zod
+        .number()
+        .optional()
+        .describe(option({ description: "Filter by Shopify variant ID" })),
+    shopifyLineItemId: zod
+        .number()
+        .optional()
+        .describe(option({ description: "Filter by Shopify line item ID" })),
+    returnOrderStatus: zod
+        .string()
+        .optional()
+        .describe(option({
+        description: "Return order status (comma-separated): requested,expected,received,in_progress,completed,cancelled",
+    })),
+    rentalStartFrom: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Rental start on/after (ISO date)" })),
+    rentalStartTo: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Rental start on/before (ISO date)" })),
+    createdFrom: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Created on/after (ISO date)" })),
+    createdTo: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Created on/before (ISO date)" })),
+    updatedSince: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Updated on/after (ISO date), for sync" })),
+    updatedTo: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Updated on/before (ISO date)" })),
+    receiveFrom: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Scheduled receive on/after (ISO date)" })),
+    receiveTo: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Scheduled receive on/before (ISO date)" })),
+    include: zod
+        .string()
+        .optional()
+        .describe(option({ description: "Relations to include, e.g. item" })),
+});
+function buildFilters(options) {
+    const filters = {
+        ...viewFilters(options),
+        fulfillmentStatus: options.fulfillment,
+        receivalStatus: options.receival,
+        customerId: options.customerId,
+        itemId: options.itemId,
+        shopifyOrderId: options.shopifyOrderId,
+        shopifyVariantId: options.shopifyVariantId,
+        shopifyLineItemId: options.shopifyLineItemId,
+        returnOrderStatus: options.returnOrderStatus,
+        include: options.include,
+    };
+    if (options.unfulfilled)
+        filters.unfulfilled = true;
+    if (options.excludeCancelled)
+        filters.excludeCancelled = true;
+    // Date-range filters: --*-from maps to gte (inclusive), --*-to maps to lte.
+    if (options.rentalStartFrom || options.rentalStartTo) {
+        filters.rentalStart = {
+            gte: options.rentalStartFrom,
+            lte: options.rentalStartTo,
+        };
+    }
+    if (options.createdFrom || options.createdTo) {
+        filters.created = { gte: options.createdFrom, lte: options.createdTo };
+    }
+    if (options.updatedSince || options.updatedTo) {
+        filters.updated = { gte: options.updatedSince, lte: options.updatedTo };
+    }
+    if (options.receiveFrom || options.receiveTo) {
+        filters.receiveAt = { gte: options.receiveFrom, lte: options.receiveTo };
+    }
+    return filters;
+}
+export default function List({ options }) {
+    return React.createElement(CyclesListView, { filters: buildFilters(options), all: options.all, json: options.json });
+}

package/dist/commands/cycles/overdue.js

@@ -0,0 +1,25 @@
+import { option } from "pastel";
+import React from "react";
+import zod from "zod";
+import CyclesListView from "../../components/CyclesListView.js";
+import { listViewShape, viewFilters } from "../../lib/listViewOptions.js";
+export const description = "Overdue cycles (returns by default, or dispatches)";
+export const options = zod.object({
+    ...listViewShape(),
+    type: zod
+        .enum(["receival", "fulfillment"])
+        .default("receival")
+        .describe(option({
+        description: "Which deadline is overdue: receival (returns) or fulfillment (dispatch)",
+    })),
+});
+export default function Overdue({ options }) {
+    const filters = { ...viewFilters(options) };
+    if (options.type === "fulfillment") {
+        filters.fulfillmentStatus = "overdue";
+    }
+    else {
+        filters.receivalStatus = "overdue";
+    }
+    return React.createElement(CyclesListView, { filters: filters, all: options.all, json: options.json });
+}