licos-platform-cli 0.2.0__tar.gz → 0.2.4__tar.gz

{licos_platform_cli-0.2.0 → licos_platform_cli-0.2.4}/.gitignore

@@ -31,6 +31,7 @@ Thumbs.db
 
 # Build
 *.log
+*.pid
 .licos
 
 /tmp
@@ -43,4 +44,6 @@ Thumbs.db
 
 dist
 
-project-20260423_130440
+project-20260423_130440
+projects-20260425_workflow
+coze-skills

licos_platform_cli-0.2.4/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: licos-platform-cli
+Version: 0.2.4
+Summary: LICOS platform CLI
+Requires-Python: >=3.10
+Requires-Dist: licos-platform-sdk>=0.2.3

{licos_platform_cli-0.2.0 → licos_platform_cli-0.2.4}/pyproject.toml

@@ -1,18 +1,18 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "licos-platform-cli"
-version = "0.2.0"
-description = "LICOS platform CLI for storage preview and download operations"
-requires-python = ">=3.10"
-dependencies = [
-    "licos-platform-sdk>=0.2.0",
-]
-
-[project.scripts]
-licos-platform = "licos_platform_cli.main:main"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/licos_platform_cli"]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "licos-platform-cli"
+version = "0.2.4"
+description = "LICOS platform CLI"
+requires-python = ">=3.10"
+dependencies = [
+    "licos-platform-sdk>=0.2.3",
+]
+
+[project.scripts]
+licos-platform = "licos_platform_cli.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/licos_platform_cli"]

{licos_platform_cli-0.2.0 → licos_platform_cli-0.2.4}/src/licos_platform_cli/__init__.py

@@ -1 +1 @@
-__all__ = ["main"]
+__all__ = ["main"]

licos_platform_cli-0.2.4/src/licos_platform_cli/database_commands.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import argparse
+import json
+from typing import Any, Callable
+
+from licos_platform_sdk import database
+
+
+Handler = Callable[[argparse.Namespace], Any]
+
+
+def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
+    parser.set_defaults(handler=handler)
+
+
+def _json_value(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return value
+
+
+def _json_object(value: str | None) -> dict[str, Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, dict):
+        raise argparse.ArgumentTypeError("value must be a JSON object")
+    return parsed
+
+
+def _json_list(value: str | None) -> list[Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, list):
+        raise argparse.ArgumentTypeError("value must be a JSON array")
+    return parsed
+
+
+def _filters(args: argparse.Namespace) -> list[dict[str, Any]] | None:
+    raw_filters = getattr(args, "filter", None) or []
+    filters = []
+    for item in raw_filters:
+        field, op, raw_value = item
+        filters.append({"field": field, "op": op, "value": _json_value(raw_value)})
+    return filters or None
+
+
+def _order_by(args: argparse.Namespace) -> list[dict[str, str]] | None:
+    raw_orders = getattr(args, "order", None) or []
+    orders = []
+    for item in raw_orders:
+        if ":" in item:
+            field, direction = item.rsplit(":", 1)
+        else:
+            field, direction = item, "asc"
+        orders.append({"field": field, "direction": direction})
+    return orders or None
+
+
+def _range(args: argparse.Namespace) -> dict[str, int] | None:
+    if not getattr(args, "range", None):
+        return None
+    start, end = args.range
+    return {"from": start, "to": end}
+
+
+def _query_options(args: argparse.Namespace) -> dict[str, Any]:
+    return {
+        "select": args.select,
+        "filters": _filters(args),
+        "order_by": _order_by(args),
+        "range": _range(args),
+        "limit": args.limit,
+        "offset": args.offset,
+        "count": args.count,
+        "head": args.head,
+    }
+
+
+def _cmd_query(args: argparse.Namespace) -> Any:
+    return database.query(args.table, **_query_options(args))
+
+
+def _cmd_single(args: argparse.Namespace) -> Any:
+    return database.single(
+        args.table,
+        maybe=args.maybe,
+        select=args.select,
+        filters=_filters(args),
+        order_by=_order_by(args),
+    )
+
+
+def _cmd_aggregate(args: argparse.Namespace) -> Any:
+    return database.aggregate(
+        args.table,
+        args.aggregate,
+        field=args.field,
+        group_by=args.group_by,
+        filters=_filters(args),
+    )
+
+
+def _cmd_insert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.insert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_update(args: argparse.Namespace) -> Any:
+    if not args.values and not args.updates:
+        raise argparse.ArgumentTypeError("--values or --updates is required")
+    return database.update(
+        args.table,
+        values=_json_object(args.values),
+        filters=_filters(args),
+        updates=_json_list(args.updates),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_delete_rows(args: argparse.Namespace) -> Any:
+    filters = _filters(args)
+    if not filters and not args.deletes:
+        raise argparse.ArgumentTypeError("--filter or --deletes is required")
+    return database.delete(
+        args.table,
+        filters=filters,
+        deletes=_json_list(args.deletes),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_upsert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.upsert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        conflict_keys=args.conflict_keys,
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_transaction(args: argparse.Namespace) -> Any:
+    operations = _json_list(args.operations)
+    if operations is None:
+        raise argparse.ArgumentTypeError("--operations is required")
+    return database.transaction(operations)
+
+
+def _cmd_rpc(args: argparse.Namespace) -> Any:
+    return database.rpc(args.function_name, args=_json_object(args.args) or {})
+
+
+def _add_filter_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--filter",
+        nargs=3,
+        action="append",
+        metavar=("FIELD", "OP", "VALUE"),
+        help="Add a filter. VALUE is parsed as JSON when possible.",
+    )
+
+
+def _add_query_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(parser)
+    parser.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    parser.add_argument("--range", nargs=2, type=int, metavar=("FROM", "TO"))
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--offset", type=int, default=None)
+    parser.add_argument("--count", action="store_true")
+    parser.add_argument("--head", action="store_true")
+
+
+def add_database_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    database_parser = subparsers.add_parser("database", help="Call LICOS runtime database APIs")
+    database_subparsers = database_parser.add_subparsers(dest="database_command", required=True)
+
+    query = database_subparsers.add_parser("query", help="Query rows")
+    query.add_argument("table")
+    _add_query_args(query)
+    _set_handler(query, _cmd_query)
+
+    single = database_subparsers.add_parser("single", help="Query a single row")
+    single.add_argument("table")
+    single.add_argument("--maybe", action="store_true", help="Allow zero rows")
+    single.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(single)
+    single.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    _set_handler(single, _cmd_single)
+
+    aggregate = database_subparsers.add_parser("aggregate", help="Run aggregate query")
+    aggregate.add_argument("table")
+    aggregate.add_argument("aggregate")
+    aggregate.add_argument("--field", default=None)
+    aggregate.add_argument("--group-by", action="append", default=None)
+    _add_filter_args(aggregate)
+    _set_handler(aggregate, _cmd_aggregate)
+
+    insert = database_subparsers.add_parser("insert", help="Insert row(s)")
+    insert.add_argument("table")
+    insert.add_argument("--row", default=None, help="JSON object")
+    insert.add_argument("--rows", default=None, help="JSON array")
+    insert.add_argument("--no-returning", action="store_true")
+    _set_handler(insert, _cmd_insert)
+
+    update = database_subparsers.add_parser("update", help="Update row(s)")
+    update.add_argument("table")
+    update.add_argument("--values", default=None, help="JSON object")
+    update.add_argument("--updates", default=None, help="JSON array of mutation batches")
+    update.add_argument("--no-returning", action="store_true")
+    _add_filter_args(update)
+    _set_handler(update, _cmd_update)
+
+    delete_rows = database_subparsers.add_parser("delete-rows", help="Delete row(s)")
+    delete_rows.add_argument("table")
+    delete_rows.add_argument("--deletes", default=None, help="JSON array of mutation batches")
+    delete_rows.add_argument("--no-returning", action="store_true")
+    _add_filter_args(delete_rows)
+    _set_handler(delete_rows, _cmd_delete_rows)
+
+    upsert = database_subparsers.add_parser("upsert", help="Upsert row(s)")
+    upsert.add_argument("table")
+    upsert.add_argument("--row", default=None, help="JSON object")
+    upsert.add_argument("--rows", default=None, help="JSON array")
+    upsert.add_argument("--conflict-keys", action="append", default=None)
+    upsert.add_argument("--no-returning", action="store_true")
+    _set_handler(upsert, _cmd_upsert)
+
+    transaction = database_subparsers.add_parser("transaction", help="Run transaction")
+    transaction.add_argument("--operations", required=True, help="JSON array")
+    _set_handler(transaction, _cmd_transaction)
+
+    rpc = database_subparsers.add_parser("rpc", help="Call database function")
+    rpc.add_argument("function_name")
+    rpc.add_argument("--args", default=None, help="JSON object")
+    _set_handler(rpc, _cmd_rpc)

licos_platform_cli-0.2.4/src/licos_platform_cli/help_commands.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any, Callable
+
+
+Handler = Callable[[argparse.Namespace], Any]
+
+
+RUNTIME_ENV = [
+    {"name": "LICOS_PLATFORM_API_BASE_URL", "description": "Platform API base URL; /api/v1 suffix is optional."},
+    {"name": "LICOS_RUNTIME_TOKEN", "description": "Runtime authorization token. Preferred over LICOS_USER_TOKEN."},
+    {"name": "LICOS_USER_TOKEN", "description": "Fallback user token for development/runtime compatibility."},
+    {"name": "LICOS_PROJECT_ID / AGENT_PROJECT_ID", "description": "Current project ID."},
+    {"name": "LICOS_WORKSPACE_ID / AGENT_WORKSPACE_ID", "description": "Current workspace ID, forwarded as X-Workspace-Id."},
+    {"name": "LICOS_USER_ID / AGENT_USER_ID", "description": "Current user ID, forwarded as X-User-Id."},
+    {"name": "LICOS_PROJECT_ENV", "description": "Project environment. prod/production/release maps to prod; otherwise dev."},
+]
+
+
+STORAGE_HELP = {
+    "topic": "storage",
+    "description": "Project object storage for folders, files, uploads, share URLs, object existence checks, moves, renames, and deletes.",
+    "runtime": [*RUNTIME_ENV, {"name": "LICOS_STORAGE_SCOPE", "description": "Optional storage scope override: dev or prod."}],
+    "rules": [
+        "Use SDK from server/runtime code; do not call from browser bundles.",
+        "Do not ask for S3 endpoint, bucket, access key, or secret key.",
+        "Do not build file URLs manually; use share-url/shareUrl.",
+        "Do not persist temporary share URLs as durable data.",
+    ],
+    "sdk": {
+        "python": "from licos_platform_sdk import storage\nfile = storage.upload_file('/workspace/projects/report.pdf')\nlink = storage.share_url(file['id'])",
+        "node": "import { storage } from '@kmlckj/licos-platform-sdk';\nconst file = await storage.uploadFile('/workspace/projects/report.pdf');\nconst link = await storage.shareUrl(file.id);",
+    },
+    "commands": {
+        "summary": {
+            "description": "Return project storage summary.",
+            "parameters": [],
+            "example": "licos-platform storage summary",
+        },
+        "folders": {
+            "description": "List all folders in the current project storage scope.",
+            "parameters": [],
+            "example": "licos-platform storage folders",
+        },
+        "entries": {
+            "description": "List folders and files under a folder; omit folder-id for root.",
+            "parameters": [{"name": "--folder-id", "required": False, "description": "Folder ID. Omit for root."}],
+            "example": "licos-platform storage entries --folder-id folder-id",
+        },
+        "files": {
+            "description": "List all files in the current project storage scope.",
+            "parameters": [],
+            "example": "licos-platform storage files",
+        },
+        "create-folder": {
+            "description": "Create a folder under root or a parent folder.",
+            "parameters": [
+                {"name": "folder_name", "required": True, "description": "New folder name."},
+                {"name": "--parent-id", "required": False, "description": "Parent folder ID. Omit for root."},
+            ],
+            "example": "licos-platform storage create-folder reports --parent-id folder-id",
+        },
+        "rename-folder": {
+            "description": "Rename a folder by folder ID.",
+            "parameters": [
+                {"name": "folder_id", "required": True, "description": "Folder ID."},
+                {"name": "folder_name", "required": True, "description": "New folder name."},
+            ],
+            "example": "licos-platform storage rename-folder folder-id reports",
+        },
+        "delete-folder": {
+            "description": "Delete a folder by folder ID.",
+            "parameters": [{"name": "folder_id", "required": True, "description": "Folder ID."}],
+            "example": "licos-platform storage delete-folder folder-id",
+        },
+        "upload-file": {
+            "description": "Upload a local file, bytes are sent as multipart form data, and the returned file object must be used.",
+            "parameters": [
+                {"name": "file", "required": True, "description": "Local file path."},
+                {"name": "--folder-id", "required": False, "description": "Target folder ID. Omit for root."},
+                {"name": "--file-name", "required": False, "description": "Override uploaded display file name."},
+                {"name": "--content-type", "required": False, "description": "MIME type, for example application/pdf."},
+            ],
+            "example": "licos-platform storage upload-file ./report.pdf --folder-id folder-id --file-name report.pdf --content-type application/pdf",
+        },
+        "rename-file": {
+            "description": "Rename a file by file ID.",
+            "parameters": [
+                {"name": "file_id", "required": True, "description": "File ID."},
+                {"name": "file_name", "required": True, "description": "New file name."},
+            ],
+            "example": "licos-platform storage rename-file file-id final.pdf",
+        },
+        "move-file": {
+            "description": "Move a file to a folder; omit folder-id to move to root.",
+            "parameters": [
+                {"name": "file_id", "required": True, "description": "File ID."},
+                {"name": "--folder-id", "required": False, "description": "Target folder ID. Omit for root."},
+            ],
+            "example": "licos-platform storage move-file file-id --folder-id folder-id",
+        },
+        "share-url": {
+            "description": "Generate a temporary share URL for a file.",
+            "parameters": [
+                {"name": "file_id", "required": True, "description": "File ID."},
+                {"name": "--expiry-seconds", "required": False, "description": "URL lifetime in seconds."},
+            ],
+            "example": "licos-platform storage share-url file-id --expiry-seconds 3600",
+        },
+        "object-exists": {
+            "description": "Check whether an object exists by file ID or object key.",
+            "parameters": [
+                {"name": "--file-id", "required": False, "description": "File ID."},
+                {"name": "--object-key", "required": False, "description": "Storage object key."},
+            ],
+            "example": "licos-platform storage object-exists --file-id file-id",
+        },
+        "delete-file": {
+            "description": "Delete a file by file ID.",
+            "parameters": [{"name": "file_id", "required": True, "description": "File ID."}],
+            "example": "licos-platform storage delete-file file-id",
+        },
+    },
+}
+
+
+DATABASE_HELP = {
+    "topic": "database",
+    "description": "Runtime database data-plane helpers for structured data CRUD, filtering, pagination, aggregation, transactions, and RPC.",
+    "runtime": RUNTIME_ENV,
+    "rules": [
+        "Use SDK from server/runtime code; do not call from browser bundles.",
+        "Do not ask for database host, port, username, password, or direct database URL.",
+        "Do not call database control-plane APIs from application code.",
+        "Require filters or explicit mutation batches for destructive update/delete operations.",
+    ],
+    "sdk": {
+        "python": "from licos_platform_sdk import database\nrows = database.table('todos').eq('done', False).limit(10).execute()",
+        "node": "import { database } from '@kmlckj/licos-platform-sdk';\nconst rows = await database.table('todos').eq('done', false).limit(10).execute();",
+    },
+    "filters": {
+        "operators": ["eq", "neq", "gt", "gte", "lt", "lte", "in", "not_in", "is_null", "is_not_null", "like", "ilike"],
+        "value_parsing": "CLI filter VALUE is parsed as JSON when possible. Use '\"open\"' for string values, false for boolean, and 3 for number.",
+    },
+    "commands": {
+        "query": {
+            "description": "Query rows with select fields, filters, ordering, range, limit, offset, and optional count/head.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--select", "required": False, "description": "Comma-separated fields."},
+                {"name": "--filter FIELD OP VALUE", "required": False, "description": "Add filter. Can be repeated."},
+                {"name": "--order", "required": False, "description": "field or field:desc. Can be repeated."},
+                {"name": "--range FROM TO", "required": False, "description": "Closed zero-based range."},
+                {"name": "--limit", "required": False, "description": "Maximum row count."},
+                {"name": "--offset", "required": False, "description": "Offset row count."},
+                {"name": "--count", "required": False, "description": "Return total count."},
+                {"name": "--head", "required": False, "description": "Return count only without rows."},
+            ],
+            "example": "licos-platform database query todos --select id,title --filter done eq false --order created_at:desc --limit 10 --count",
+        },
+        "single": {
+            "description": "Query exactly one row, or zero/one row with --maybe.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--maybe", "required": False, "description": "Allow zero rows."},
+                {"name": "--select", "required": False, "description": "Comma-separated fields."},
+                {"name": "--filter FIELD OP VALUE", "required": False, "description": "Add filter. Can be repeated."},
+                {"name": "--order", "required": False, "description": "field or field:desc. Can be repeated."},
+            ],
+            "example": "licos-platform database single todos --maybe --filter id eq '\"todo-1\"'",
+        },
+        "aggregate": {
+            "description": "Run aggregate query such as count, sum, avg, min, or max.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "aggregate", "required": True, "description": "Aggregate function name."},
+                {"name": "--field", "required": False, "description": "Aggregate field. count may omit it."},
+                {"name": "--group-by", "required": False, "description": "Group-by field. Can be repeated."},
+                {"name": "--filter FIELD OP VALUE", "required": False, "description": "Add filter. Can be repeated."},
+            ],
+            "example": "licos-platform database aggregate todos count --filter done eq false",
+        },
+        "insert": {
+            "description": "Insert one row or multiple rows.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--row", "required": False, "description": "JSON object for one row."},
+                {"name": "--rows", "required": False, "description": "JSON array for batch insert."},
+                {"name": "--no-returning", "required": False, "description": "Do not return inserted rows."},
+            ],
+            "example": "licos-platform database insert todos --row '{\"title\":\"A\",\"done\":false}'",
+        },
+        "update": {
+            "description": "Update rows by filters or mutation batches.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--values", "required": False, "description": "JSON object of fields to update."},
+                {"name": "--updates", "required": False, "description": "JSON array of update batches."},
+                {"name": "--filter FIELD OP VALUE", "required": False, "description": "Add filter. Can be repeated."},
+                {"name": "--no-returning", "required": False, "description": "Do not return updated rows."},
+            ],
+            "example": "licos-platform database update todos --values '{\"done\":true}' --filter id eq '\"todo-1\"'",
+        },
+        "delete-rows": {
+            "description": "Delete rows by filters or delete batches.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--filter FIELD OP VALUE", "required": False, "description": "Add filter. Can be repeated."},
+                {"name": "--deletes", "required": False, "description": "JSON array of delete batches."},
+                {"name": "--no-returning", "required": False, "description": "Do not return deleted rows."},
+            ],
+            "example": "licos-platform database delete-rows todos --filter id eq '\"todo-1\"'",
+        },
+        "upsert": {
+            "description": "Insert or update rows by conflict keys.",
+            "parameters": [
+                {"name": "table", "required": True, "description": "Table name."},
+                {"name": "--row", "required": False, "description": "JSON object for one row."},
+                {"name": "--rows", "required": False, "description": "JSON array for batch upsert."},
+                {"name": "--conflict-keys", "required": False, "description": "Conflict key. Can be repeated."},
+                {"name": "--no-returning", "required": False, "description": "Do not return upserted rows."},
+            ],
+            "example": "licos-platform database upsert todos --row '{\"id\":\"todo-1\",\"title\":\"A\"}' --conflict-keys id",
+        },
+        "transaction": {
+            "description": "Run multiple runtime database operations in one transaction.",
+            "parameters": [{"name": "--operations", "required": True, "description": "JSON array of operations."}],
+            "example": "licos-platform database transaction --operations '[{\"type\":\"insert\",\"request\":{\"table\":\"todos\",\"row\":{\"title\":\"A\"}}}]'",
+        },
+        "rpc": {
+            "description": "Call a platform database function.",
+            "parameters": [
+                {"name": "function_name", "required": True, "description": "Function name."},
+                {"name": "--args", "required": False, "description": "JSON object of function arguments."},
+            ],
+            "example": "licos-platform database rpc recalculate_stats --args '{\"user_id\":\"user-1\"}'",
+        },
+    },
+}
+
+
+HELP_TOPICS = {
+    "storage": STORAGE_HELP,
+    "database": DATABASE_HELP,
+}
+
+
+def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
+    parser.set_defaults(handler=handler)
+
+
+def _cmd_help(args: argparse.Namespace) -> dict[str, Any]:
+    if not args.topic:
+        return {
+            "description": "Structured help for LICOS platform CLI topics.",
+            "usage": [
+                "licos-platform help storage",
+                "licos-platform help storage upload-file",
+                "licos-platform help database",
+                "licos-platform help database query",
+            ],
+            "topics": sorted(HELP_TOPICS),
+        }
+    topic = HELP_TOPICS[args.topic]
+    if not args.command:
+        return topic
+    command = topic["commands"].get(args.command)
+    if not command:
+        raise argparse.ArgumentTypeError(f"unknown {args.topic} command: {args.command}")
+    return {
+        "topic": args.topic,
+        "command": args.command,
+        **command,
+    }
+
+
+def add_help_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    help_parser = subparsers.add_parser("help", help="Show structured JSON help for LICOS platform CLI topics")
+    help_parser.add_argument("topic", nargs="?", choices=sorted(HELP_TOPICS), help="Help topic")
+    help_parser.add_argument("command", nargs="?", help="Optional command name inside the topic")
+    _set_handler(help_parser, _cmd_help)

licos_platform_cli-0.2.4/src/licos_platform_cli/main.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Sequence
+
+from licos_platform_sdk import PlatformSdkError
+
+from .database_commands import add_database_parser
+from .help_commands import add_help_parser
+from .storage_commands import add_storage_parser
+
+
+def _print_json(value: Any) -> None:
+    print(json.dumps(value, ensure_ascii=False, indent=2))
+
+
+def _handle_result(value: Any) -> int:
+    _print_json({"success": True} if value is None else value)
+    return 0
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="licos-platform",
+        description="LICOS platform CLI. Runtime configuration is read from LICOS_* environment variables.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    add_help_parser(subparsers)
+    add_storage_parser(subparsers)
+    add_database_parser(subparsers)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _build_parser()
+    try:
+        args = parser.parse_args(argv)
+        return _handle_result(args.handler(args))
+    except argparse.ArgumentTypeError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    except PlatformSdkError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

licos_platform_cli-0.2.4/src/licos_platform_cli/storage_commands.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any, Callable
+
+from licos_platform_sdk import storage
+
+
+Handler = Callable[[argparse.Namespace], Any]
+
+
+def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
+    parser.set_defaults(handler=handler)
+
+
+def _cmd_summary(_args: argparse.Namespace) -> Any:
+    return storage.summary()
+
+
+def _cmd_folders(_args: argparse.Namespace) -> Any:
+    return storage.list_folders()
+
+
+def _cmd_entries(args: argparse.Namespace) -> Any:
+    return storage.list_entries(folder_id=args.folder_id)
+
+
+def _cmd_files(_args: argparse.Namespace) -> Any:
+    return storage.list_files()
+
+
+def _cmd_create_folder(args: argparse.Namespace) -> Any:
+    return storage.create_folder(args.folder_name, parent_id=args.parent_id)
+
+
+def _cmd_rename_folder(args: argparse.Namespace) -> Any:
+    return storage.rename_folder(args.folder_id, args.folder_name)
+
+
+def _cmd_delete_folder(args: argparse.Namespace) -> Any:
+    return storage.delete_folder(args.folder_id)
+
+
+def _cmd_upload_file(args: argparse.Namespace) -> Any:
+    return storage.upload_file(
+        args.file,
+        folder_id=args.folder_id,
+        file_name=args.file_name,
+        content_type=args.content_type,
+    )
+
+
+def _cmd_rename_file(args: argparse.Namespace) -> Any:
+    return storage.rename_file(args.file_id, args.file_name)
+
+
+def _cmd_move_file(args: argparse.Namespace) -> Any:
+    return storage.move_file(args.file_id, folder_id=args.folder_id)
+
+
+def _cmd_share_url(args: argparse.Namespace) -> Any:
+    return storage.share_url(args.file_id, expiry_seconds=args.expiry_seconds)
+
+
+def _cmd_object_exists(args: argparse.Namespace) -> Any:
+    if not args.file_id and not args.object_key:
+        raise argparse.ArgumentTypeError("--file-id or --object-key is required")
+    return storage.object_exists(file_id=args.file_id, object_key=args.object_key)
+
+
+def _cmd_delete_file(args: argparse.Namespace) -> Any:
+    return storage.delete_file(args.file_id)
+
+
+def add_storage_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    storage_parser = subparsers.add_parser("storage", help="Call LICOS Studio object storage APIs")
+    storage_subparsers = storage_parser.add_subparsers(dest="storage_command", required=True)
+
+    _set_handler(storage_subparsers.add_parser("summary", help="Show storage summary"), _cmd_summary)
+    _set_handler(storage_subparsers.add_parser("folders", help="List folders"), _cmd_folders)
+
+    entries = storage_subparsers.add_parser("entries", help="List entries in a folder")
+    entries.add_argument("--folder-id", default=None, help="Folder ID; omit for root")
+    _set_handler(entries, _cmd_entries)
+
+    _set_handler(storage_subparsers.add_parser("files", help="List files"), _cmd_files)
+
+    create_folder = storage_subparsers.add_parser("create-folder", help="Create a folder")
+    create_folder.add_argument("folder_name")
+    create_folder.add_argument("--parent-id", default=None)
+    _set_handler(create_folder, _cmd_create_folder)
+
+    rename_folder = storage_subparsers.add_parser("rename-folder", help="Rename a folder")
+    rename_folder.add_argument("folder_id")
+    rename_folder.add_argument("folder_name")
+    _set_handler(rename_folder, _cmd_rename_folder)
+
+    delete_folder = storage_subparsers.add_parser("delete-folder", help="Delete a folder")
+    delete_folder.add_argument("folder_id")
+    _set_handler(delete_folder, _cmd_delete_folder)
+
+    upload_file = storage_subparsers.add_parser("upload-file", help="Upload a file")
+    upload_file.add_argument("file", help="Local file path")
+    upload_file.add_argument("--folder-id", default=None)
+    upload_file.add_argument("--file-name", default=None, help="Override uploaded file name")
+    upload_file.add_argument("--content-type", default=None)
+    _set_handler(upload_file, _cmd_upload_file)
+
+    rename_file = storage_subparsers.add_parser("rename-file", help="Rename a file")
+    rename_file.add_argument("file_id")
+    rename_file.add_argument("file_name")
+    _set_handler(rename_file, _cmd_rename_file)
+
+    move_file = storage_subparsers.add_parser("move-file", help="Move a file")
+    move_file.add_argument("file_id")
+    move_file.add_argument("--folder-id", default=None, help="Target folder ID; omit for root")
+    _set_handler(move_file, _cmd_move_file)
+
+    share_url = storage_subparsers.add_parser("share-url", help="Create a file share URL")
+    share_url.add_argument("file_id")
+    share_url.add_argument("--expiry-seconds", type=int, default=None)
+    _set_handler(share_url, _cmd_share_url)
+
+    exists = storage_subparsers.add_parser("object-exists", help="Check object existence")
+    exists.add_argument("--file-id", default=None)
+    exists.add_argument("--object-key", default=None)
+    _set_handler(exists, _cmd_object_exists)
+
+    delete_file = storage_subparsers.add_parser("delete-file", help="Delete a file")
+    delete_file.add_argument("file_id")
+    _set_handler(delete_file, _cmd_delete_file)

licos_platform_cli-0.2.4/tests/test_cli.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import io
+import json
+import sys
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "licos-platform-sdk" / "src"))
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from licos_platform_cli import main as cli_main
+from licos_platform_cli import database_commands, storage_commands
+from licos_platform_sdk import ApiError
+
+
+def run_cli(*args: str) -> tuple[int, str, str]:
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    with redirect_stdout(stdout), redirect_stderr(stderr):
+        try:
+            code = cli_main.main(list(args))
+        except SystemExit as exc:
+            code = int(exc.code or 0)
+    return code, stdout.getvalue(), stderr.getvalue()
+
+
+class PlatformCliTests(unittest.TestCase):
+    def test_help_exposes_storage_commands(self) -> None:
+        stdout = io.StringIO()
+        with self.assertRaises(SystemExit) as caught, redirect_stdout(stdout):
+            cli_main.main(["--help"])
+
+        self.assertEqual(caught.exception.code, 0)
+        self.assertIn("help", stdout.getvalue())
+        self.assertIn("storage", stdout.getvalue())
+        self.assertIn("database", stdout.getvalue())
+
+    def test_structured_help_lists_topics(self) -> None:
+        code, stdout, stderr = run_cli("help")
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        payload = json.loads(stdout)
+        self.assertEqual(payload["topics"], ["database", "storage"])
+        self.assertIn("licos-platform help storage", payload["usage"])
+
+    def test_structured_help_storage_command_describes_parameters(self) -> None:
+        code, stdout, stderr = run_cli("help", "storage", "upload-file")
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        payload = json.loads(stdout)
+        self.assertEqual(payload["topic"], "storage")
+        self.assertEqual(payload["command"], "upload-file")
+        self.assertIn("Upload a local file", payload["description"])
+        self.assertIn("--content-type", [item["name"] for item in payload["parameters"]])
+
+    def test_structured_help_database_topic_includes_sdk_and_filter_docs(self) -> None:
+        code, stdout, stderr = run_cli("help", "database")
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        payload = json.loads(stdout)
+        self.assertEqual(payload["topic"], "database")
+        self.assertIn("python", payload["sdk"])
+        self.assertIn("node", payload["sdk"])
+        self.assertIn("eq", payload["filters"]["operators"])
+        self.assertNotIn("LICOS_DATABASE_ENVIRONMENT", {item["name"] for item in payload["runtime"]})
+
+    def test_storage_files_wraps_sdk_and_outputs_json(self) -> None:
+        with mock.patch.object(storage_commands.storage, "list_files", return_value=[{"id": "file-1"}]) as list_files:
+            code, stdout, stderr = run_cli("storage", "files")
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        self.assertEqual(json.loads(stdout), [{"id": "file-1"}])
+        list_files.assert_called_once_with()
+
+    def test_storage_upload_file_forwards_only_user_level_options(self) -> None:
+        with mock.patch.object(storage_commands.storage, "upload_file", return_value={"id": "file-1"}) as upload_file:
+            code, stdout, stderr = run_cli(
+                "storage",
+                "upload-file",
+                "report.pdf",
+                "--folder-id",
+                "folder-1",
+                "--file-name",
+                "final.pdf",
+                "--content-type",
+                "application/pdf",
+            )
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        self.assertEqual(json.loads(stdout), {"id": "file-1"})
+        upload_file.assert_called_once_with(
+            "report.pdf",
+            folder_id="folder-1",
+            file_name="final.pdf",
+            content_type="application/pdf",
+        )
+
+    def test_storage_share_url_forwards_expiry(self) -> None:
+        with mock.patch.object(storage_commands.storage, "share_url", return_value={"url": "https://example.test"}) as share_url:
+            code, stdout, stderr = run_cli("storage", "share-url", "file-1", "--expiry-seconds", "60")
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        self.assertEqual(json.loads(stdout), {"url": "https://example.test"})
+        share_url.assert_called_once_with("file-1", expiry_seconds=60)
+
+    def test_storage_object_exists_requires_lookup_key(self) -> None:
+        code, stdout, stderr = run_cli("storage", "object-exists")
+
+        self.assertEqual(code, 2)
+        self.assertEqual(stdout, "")
+        self.assertIn("--file-id or --object-key is required", stderr)
+
+    def test_storage_delete_service_is_not_exposed(self) -> None:
+        code, stdout, stderr = run_cli("storage", "delete-service", "--yes")
+
+        self.assertEqual(code, 2)
+        self.assertEqual(stdout, "")
+        self.assertIn("invalid choice", stderr)
+
+    def test_sdk_errors_return_cli_failure(self) -> None:
+        with mock.patch.object(storage_commands.storage, "summary", side_effect=ApiError("platform failed")):
+            code, stdout, stderr = run_cli("storage", "summary")
+
+        self.assertEqual(code, 1)
+        self.assertEqual(stdout, "")
+        self.assertIn("platform failed", stderr)
+
+    def test_database_query_forwards_runtime_options(self) -> None:
+        with mock.patch.object(database_commands.database, "query", return_value={"rows": []}) as query:
+            code, stdout, stderr = run_cli(
+                "database",
+                "query",
+                "todos",
+                "--select",
+                "id,title",
+                "--filter",
+                "done",
+                "eq",
+                "false",
+                "--order",
+                "created_at:desc",
+                "--limit",
+                "10",
+                "--count",
+            )
+
+        self.assertEqual(code, 0)
+        self.assertEqual(stderr, "")
+        self.assertEqual(json.loads(stdout), {"rows": []})
+        query.assert_called_once_with(
+            "todos",
+            select="id,title",
+            filters=[{"field": "done", "op": "eq", "value": False}],
+            order_by=[{"field": "created_at", "direction": "desc"}],
+            range=None,
+            limit=10,
+            offset=None,
+            count=True,
+            head=False,
+        )
+
+    def test_database_transaction_requires_operations_array(self) -> None:
+        code, stdout, stderr = run_cli("database", "transaction", "--operations", "{}")
+
+        self.assertEqual(code, 2)
+        self.assertEqual(stdout, "")
+        self.assertIn("value must be a JSON array", stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

licos_platform_cli-0.2.0/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.4
-Name: licos-platform-cli
-Version: 0.2.0
-Summary: LICOS platform CLI for storage preview and download operations
-Requires-Python: >=3.10
-Requires-Dist: licos-platform-sdk>=0.2.0

licos_platform_cli-0.2.0/src/licos_platform_cli/main.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-from typing import Sequence
-
-from licos_platform_sdk import download, download_url, preview_url
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="licos-platform")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    storage = subparsers.add_parser("storage", help="Platform storage operations")
-    storage_subparsers = storage.add_subparsers(dest="storage_command", required=True)
-
-    preview_url_cmd = storage_subparsers.add_parser("preview-url", help="Build a public preview URL")
-    preview_url_cmd.add_argument("bucket", help="Bucket name")
-    preview_url_cmd.add_argument("object_key", help="Object key")
-
-    download_url_cmd = storage_subparsers.add_parser("download-url", help="Build a public download URL")
-    download_url_cmd.add_argument("bucket", help="Bucket name")
-    download_url_cmd.add_argument("object_key", help="Object key")
-
-    download_cmd = storage_subparsers.add_parser("download", help="Download a public file URL to disk")
-    download_cmd.add_argument("url", help="Public storage URL")
-    download_cmd.add_argument("--output", required=True, help="Destination path")
-
-    return parser
-
-
-def _print_json(payload: dict) -> None:
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-def main(argv: Sequence[str] | None = None) -> int:
-    parser = _build_parser()
-    args = parser.parse_args(argv)
-
-    if args.command != "storage":
-        parser.error(f"Unsupported command: {args.command}")
-
-    if args.storage_command == "preview-url":
-        _print_json(
-            {
-                "preview_url": preview_url(args.bucket, args.object_key),
-            }
-        )
-        return 0
-
-    if args.storage_command == "download-url":
-        _print_json(
-            {
-                "download_url": download_url(args.bucket, args.object_key),
-            }
-        )
-        return 0
-
-    if args.storage_command == "download":
-        saved_path = download(args.url, Path(args.output))
-        _print_json({"path": str(saved_path)})
-        return 0
-
-    parser.error(f"Unsupported storage command: {args.storage_command}")
-    return 2
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

licos_platform_cli-0.2.0/tests/test_cli.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-
-class PlatformCliTests(unittest.TestCase):
-    def test_storage_help_does_not_expose_minio_upload_commands(self) -> None:
-        env = os.environ.copy()
-        env["PYTHONPATH"] = os.pathsep.join(
-            [
-                str(Path(__file__).resolve().parents[2] / "licos-platform-sdk" / "src"),
-                str(Path(__file__).resolve().parents[1] / "src"),
-                env.get("PYTHONPATH", ""),
-            ]
-        ).strip(os.pathsep)
-
-        proc = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "licos_platform_cli.main",
-                "storage",
-                "--help",
-            ],
-            capture_output=True,
-            check=True,
-            text=True,
-            env=env,
-        )
-
-        self.assertNotIn("upload-user", proc.stdout)
-        self.assertNotIn("upload-project", proc.stdout)
-
-    def test_preview_url_command_prints_json(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            file_path = Path(tmp_dir) / "demo.txt"
-            file_path.write_text("hello world", encoding="utf-8")
-            env = os.environ.copy()
-            env["PYTHONPATH"] = os.pathsep.join(
-                [
-                    str(Path(__file__).resolve().parents[2] / "licos-platform-sdk" / "src"),
-                    str(Path(__file__).resolve().parents[1] / "src"),
-                    env.get("PYTHONPATH", ""),
-                ]
-            ).strip(os.pathsep)
-            env["LICOS_ORCHESTRATOR_API_BASE_URL"] = "http://127.0.0.1:9"
-            env["LICOS_USER_TOKEN"] = "user_token"
-            env["LICOS_USER_ID"] = "demo-user"
-            env["LICOS_PROJECT_ID"] = "demo-project"
-
-            proc = subprocess.run(
-                [
-                    sys.executable,
-                    "-m",
-                    "licos_platform_cli.main",
-                    "storage",
-                    "preview-url",
-                    "demo-bucket",
-                    "folder/report.txt",
-                ],
-                capture_output=True,
-                check=True,
-                text=True,
-                env=env,
-            )
-
-        payload = json.loads(proc.stdout)
-        self.assertEqual(
-            payload["preview_url"],
-            "http://127.0.0.1:9/api/v1/public/storage/demo-bucket/folder/report.txt",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()