@dhf-hermes/grix 0.1.0

package/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.DS_Store
+*.log
+dist/
+tmp/
+coverage/

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# grix-hermes
+
+`grix-hermes` 是一个独立发布的 Hermes 技能包项目。
+它对外发布到 npm 的包名是 `@dhf-hermes/grix`，安装后的命令仍然是 `grix-hermes`。
+
+它的目标很单一：
+
+- 不修改 Hermes 内核
+- 复用 Hermes 已有的 `terminal` 和 `send_message`
+- 把 Grix / OpenClaw 相关技能做成可单独安装、可 npm 发布、可 GitHub 发布的技能包
+
+## 包含内容
+
+- 9 个迁移后的技能
+- 一套共享 Grix WS CLI，给 `grix-query`、`grix-group`、`grix-admin`、`message-unsend` 使用
+- 独立 HTTP 组件，给 `grix-register` 使用
+- OpenClaw 本地运维脚本，给 `openclaw-memory-setup` 使用
+
+## 安装
+
+### 方式 1：npm
+
+```bash
+npm install -g @dhf-hermes/grix
+grix-hermes install
+```
+
+默认会安装到：
+
+```text
+~/.hermes/skills/grix-hermes
+```
+
+如果你用了自定义 `HERMES_HOME`，安装器会跟随它。
+
+### 方式 2：GitHub / 本地目录
+
+```bash
+git clone <repo> /path/to/grix-hermes
+```
+
+然后可以二选一：
+
+1. 直接把仓库根目录作为 `skills.external_dirs`
+2. 执行 `node ./bin/grix-hermes.mjs install --dest <目标目录>`
+
+## 命令
+
+```bash
+grix-hermes list
+grix-hermes manifest
+grix-hermes install
+grix-hermes install --dest ~/.hermes/skills/grix-hermes --force
+```
+
+## GitHub / npm 发布
+
+仓库已经带了两条工作流：
+
+- `.github/workflows/ci.yml`
+- `.github/workflows/publish.yml`
+
+发布时只需要准备：
+
+1. GitHub 仓库
+2. npm 包名：`@dhf-hermes/grix`
+3. GitHub Secret: `NPM_TOKEN`
+
+仓库里也带了本地发布脚本：
+
+- `./publish.sh`
+- `./scripts/publish_npm.sh`
+
+常用方式：
+
+```bash
+bash ./publish.sh
+bash ./publish.sh --publish
+```
+
+## 设计边界
+
+- Grix 查询、群管理、远端 Agent 管理、消息撤回：走 Grix WS 协议
+- 注册、发验证码、创建首个 API agent：走独立 HTTP 组件
+- 发消息、发卡片：优先使用 Hermes 自带 `send_message`
+- 本项目不依赖修改 Hermes 内核，也不要求给 Hermes 增加新 tool
+
+## 技能清单
+
+- `grix-admin`
+- `grix-egg`
+- `grix-group`
+- `grix-query`
+- `grix-register`
+- `grix-update`
+- `message-send`
+- `message-unsend`
+- `openclaw-memory-setup`

package/bin/grix-hermes.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { defaultInstallDir, installEntries, manifestData, projectRoot, SKILLS } from "../lib/manifest.mjs";
+
+function printHelp() {
+  console.log(`grix-hermes
+
+Usage:
+  grix-hermes list
+  grix-hermes manifest
+  grix-hermes install [--dest <dir>] [--force]
+`);
+}
+
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return { positional, flags };
+}
+
+function copyRecursive(src, dest, force) {
+  if (fs.existsSync(dest)) {
+    if (!force) {
+      throw new Error(`Destination already exists: ${dest}. Use --force to overwrite.`);
+    }
+    fs.rmSync(dest, { recursive: true, force: true });
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.cpSync(src, dest, { recursive: true });
+}
+
+function runInstall(flags) {
+  const root = projectRoot();
+  const destRoot = path.resolve(String(flags.dest || defaultInstallDir()));
+  fs.mkdirSync(destRoot, { recursive: true });
+  for (const entry of installEntries()) {
+    copyRecursive(path.join(root, entry), path.join(destRoot, entry), Boolean(flags.force));
+  }
+  console.log(destRoot);
+}
+
+function runList() {
+  for (const skill of SKILLS) {
+    console.log(`${skill.name}\t${skill.description}`);
+  }
+}
+
+function runManifest() {
+  console.log(JSON.stringify(manifestData(), null, 2));
+}
+
+const { positional, flags } = parseArgs(process.argv.slice(2));
+const command = positional[0] || "help";
+
+if (command === "help" || command === "--help" || command === "-h") {
+  printHelp();
+  process.exit(0);
+}
+
+if (command === "list") {
+  runList();
+  process.exit(0);
+}
+
+if (command === "manifest") {
+  runManifest();
+  process.exit(0);
+}
+
+if (command === "install") {
+  runInstall(flags);
+  process.exit(0);
+}
+
+printHelp();
+process.exit(1);

package/grix-admin/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: grix-admin
+description: 需要创建远端 Grix API agent、管理分类、并把结果落地到本地 OpenClaw 配置时使用。适用于首个 agent 绑定、后续创建并绑定 agent、分类管理。远端步骤通过 `../shared/cli/grix-hermes.mjs admin`，本地步骤通过 `openclaw` 官方 CLI。
+---
+
+# Grix Admin
+
+这个技能负责两件事：
+
+1. 远端 Grix agent / 分类管理
+2. 本地 OpenClaw 绑定和校验
+
+不要手工改 `openclaw.json`。
+
+## Mode A: bind-local
+
+当上下文已经给出：
+
+- `agent_name`
+- `agent_id`
+- `api_endpoint`
+- `api_key`
+
+就直接做本地绑定，不做远端创建。
+
+### 本地绑定主线
+
+1. 先用 `openclaw config get --json` 读取：
+   - `channels.grix.accounts`
+   - `agents.list`
+   - `tools.profile`
+   - `tools.alsoAllow`
+   - `tools.sessions.visibility`
+2. 准备目标值：
+   - `channels.grix.accounts.<agent_name>`
+   - `agents.list` 里目标 agent
+   - `tools.profile="coding"`
+   - `tools.alsoAllow` 至少包含 `message`、`grix_register`
+3. 用官方命令写入：
+   - `openclaw config set ... --strict-json`
+   - `openclaw agents bind --agent <agent_name> --bind grix:<agent_name>`
+4. 校验：
+   - `openclaw config validate`
+   - `openclaw config get --json channels.grix.accounts.<agent_name>`
+   - `openclaw agents bindings --agent <agent_name> --json`
+
+### model 规则
+
+- 先复用该 agent 现有 `model`
+- 没有则看 `agents.defaults.model.primary`
+- 还没有就停止，不要猜
+
+## Mode B: create-and-bind
+
+如果还没有远端 agent，就先创建。
+
+### 远端创建
+
+通过 `terminal` 执行：
+
+```bash
+node scripts/admin.mjs --action create_agent --agent-name <NAME> [--introduction ...] [--is-main true|false]
+```
+
+如果需要分类：
+
+```bash
+node scripts/admin.mjs --action create_agent --agent-name <NAME> --category-id <ID>
+node scripts/admin.mjs --action create_agent --agent-name <NAME> --category-name <NAME> --parent-category-id 0
+```
+
+创建成功后，拿返回里的 `id` / `agent_name` / `api_endpoint` / `api_key`，继续走本地绑定 helper：
+
+```bash
+python3 scripts/bind_local.py \
+  --agent-name <AGENT_NAME> \
+  --agent-id <AGENT_ID> \
+  --api-endpoint <WS_URL> \
+  --api-key <API_KEY> \
+  --model <MODEL>
+```
+
+如果你已经拿到一份远端创建结果 JSON，可以直接交给：
+
+```bash
+python3 scripts/bind_from_json.py --model <MODEL> --dry-run --json < result.json
+```
+
+## Mode C: category-manage
+
+分类相关动作统一走：
+
+```bash
+node scripts/admin.mjs --action list_categories
+node scripts/admin.mjs --action create_category --name <NAME> --parent-id 0
+node scripts/admin.mjs --action update_category --category-id <ID> --name <NAME> --parent-id 0
+node scripts/admin.mjs --action assign_category --agent-id <AGENT_ID> --category-id <CATEGORY_ID>
+```
+
+## Guardrails
+
+- 远端动作不要改走 HTTP
+- 本地配置不要手工编辑 JSON
+- 安装私聊进行中时，不要主动重启 gateway
+- 只有配置已确认正确但运行态明显是旧结果时，才把 `openclaw gateway restart` 当补救
+
+## 参考
+
+- [Hermes Grix Runtime](../shared/references/hermes-grix-config.md)

package/grix-admin/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Grix Admin"
+  short_description: "Create remote agents and bind local OpenClaw."
+  default_prompt: "Use $grix-admin to create a remote Grix API agent and bind it into OpenClaw."
+
+policy:
+  allow_implicit_invocation: true

package/grix-admin/scripts/admin.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sharedCli = path.resolve(scriptDir, "../../shared/cli/grix-hermes.mjs");
+const result = spawnSync(process.execPath, [sharedCli, "admin", ...process.argv.slice(2)], {
+  stdio: "inherit",
+});
+process.exit(result.status ?? 1);

package/grix-admin/scripts/bind_from_json.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Extract bind-local fields from JSON and forward them to bind_local.py."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+from typing import Any
+
+
+def load_payload(args: argparse.Namespace) -> dict[str, Any]:
+    if args.from_file:
+        return json.loads(Path(args.from_file).read_text(encoding="utf-8"))
+    raw = sys.stdin.read().strip()
+    if not raw:
+        raise RuntimeError("No JSON input provided.")
+    return json.loads(raw)
+
+
+def clean_text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def as_record(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def extract_bind_fields(payload: dict[str, Any]) -> dict[str, str]:
+    handoff = as_record(payload.get("handoff"))
+    bind_local = as_record(handoff.get("bind_local"))
+    if bind_local:
+        return {
+            "agent_name": clean_text(bind_local.get("agent_name")),
+            "agent_id": clean_text(bind_local.get("agent_id")),
+            "api_endpoint": clean_text(bind_local.get("api_endpoint")),
+            "api_key": clean_text(bind_local.get("api_key")),
+        }
+
+    created_agent = as_record(payload.get("createdAgent"))
+    if created_agent:
+        return {
+            "agent_name": clean_text(created_agent.get("agent_name") or created_agent.get("name")),
+            "agent_id": clean_text(created_agent.get("id") or created_agent.get("agent_id")),
+            "api_endpoint": clean_text(created_agent.get("api_endpoint") or payload.get("api_endpoint")),
+            "api_key": clean_text(created_agent.get("api_key") or payload.get("api_key")),
+        }
+
+    return {
+        "agent_name": clean_text(payload.get("agent_name") or payload.get("name")),
+        "agent_id": clean_text(payload.get("agent_id") or payload.get("id")),
+        "api_endpoint": clean_text(payload.get("api_endpoint")),
+        "api_key": clean_text(payload.get("api_key")),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Read agent JSON and forward it to bind_local.py.")
+    parser.add_argument("--from-file", default="")
+    parser.add_argument("--model", default="")
+    parser.add_argument("--openclaw", default="openclaw")
+    parser.add_argument("--openclaw-home", default="")
+    parser.add_argument("--skip-current", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    try:
+        payload = load_payload(args)
+        bind_fields = extract_bind_fields(payload)
+        missing = [key for key, value in bind_fields.items() if not value]
+        if missing:
+            raise RuntimeError(f"Missing bind-local fields: {', '.join(missing)}")
+        bind_script = Path(__file__).with_name("bind_local.py")
+        cmd = [
+            sys.executable,
+            str(bind_script),
+            "--agent-name",
+            bind_fields["agent_name"],
+            "--agent-id",
+            bind_fields["agent_id"],
+            "--api-endpoint",
+            bind_fields["api_endpoint"],
+            "--api-key",
+            bind_fields["api_key"],
+            "--openclaw",
+            args.openclaw,
+        ]
+        if args.model:
+            cmd.extend(["--model", args.model])
+        if args.openclaw_home:
+            cmd.extend(["--openclaw-home", args.openclaw_home])
+        if args.skip_current:
+            cmd.append("--skip-current")
+        if args.dry_run:
+            cmd.append("--dry-run")
+        if args.json:
+            cmd.append("--json")
+
+        result = subprocess.run(cmd, text=True, capture_output=True)
+        if result.returncode != 0:
+            raise RuntimeError((result.stderr or result.stdout or "").strip())
+
+        if result.stdout:
+            sys.stdout.write(result.stdout)
+        return 0
+    except Exception as exc:  # noqa: BLE001
+        if args.json:
+            print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2), file=sys.stderr)
+        else:
+            print(str(exc), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/grix-admin/scripts/bind_local.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""Bind one remote Grix API agent into local OpenClaw config."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+from typing import Any
+
+
+MINIMAL_PERSONA_FILES = {
+    "IDENTITY.md": "# Identity\n\nThis agent is managed by grix-hermes.\n",
+    "SOUL.md": "# Soul\n\nRespond clearly and keep the workflow moving.\n",
+    "AGENTS.md": "# Agents\n\nUse the current workspace and configured tools.\n",
+}
+
+
+def run_command(cmd: list[str], *, check: bool = True) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(cmd, text=True, capture_output=True)
+    if check and result.returncode != 0:
+        stderr = (result.stderr or "").strip()
+        stdout = (result.stdout or "").strip()
+        raise RuntimeError(stderr or stdout or f"command failed: {' '.join(cmd)}")
+    return result
+
+
+def safe_config_get(openclaw_cmd: str, path: str, default: Any) -> Any:
+    result = subprocess.run(
+        [openclaw_cmd, "config", "get", path, "--json"],
+        text=True,
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        return default
+    text = (result.stdout or "").strip()
+    if not text:
+        return default
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return default
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def ensure_minimal_persona(workspace: Path) -> list[str]:
+    ensure_dir(workspace)
+    created: list[str] = []
+    for file_name, content in MINIMAL_PERSONA_FILES.items():
+        file_path = workspace / file_name
+        if file_path.exists():
+            continue
+        file_path.write_text(content, encoding="utf-8")
+        created.append(str(file_path))
+    return created
+
+
+def merge_tool_allowlist(current: Any) -> list[str]:
+    existing: list[str] = []
+    if isinstance(current, list):
+        for item in current:
+            text = str(item or "").strip()
+            if text:
+                existing.append(text)
+    if "message" not in existing:
+        existing.append("message")
+    return existing
+
+
+def resolve_model(args: argparse.Namespace, agents_list: list[dict[str, Any]], openclaw_cmd: str, skip_current: bool) -> str:
+    explicit = str(args.model or "").strip()
+    if explicit:
+        return explicit
+    for entry in agents_list:
+        if str(entry.get("id") or "").strip() == args.agent_name:
+            model = str(entry.get("model") or "").strip()
+            if model:
+                return model
+    if skip_current:
+        return ""
+    defaults = safe_config_get(openclaw_cmd, "agents.defaults.model.primary", "")
+    return str(defaults or "").strip()
+
+
+def build_plan(args: argparse.Namespace) -> dict[str, Any]:
+    openclaw_cmd = args.openclaw
+    skip_current = bool(args.skip_current)
+    current_accounts = {} if skip_current else safe_config_get(openclaw_cmd, "channels.grix.accounts", {})
+    current_agents = [] if skip_current else safe_config_get(openclaw_cmd, "agents.list", [])
+    current_profile = "coding" if skip_current else safe_config_get(openclaw_cmd, "tools.profile", "coding")
+    current_allow = [] if skip_current else safe_config_get(openclaw_cmd, "tools.alsoAllow", [])
+    current_visibility = "agent" if skip_current else safe_config_get(openclaw_cmd, "tools.sessions.visibility", "agent")
+    current_grix_enabled = True if skip_current else safe_config_get(openclaw_cmd, "channels.grix.enabled", True)
+
+    openclaw_root = Path(os.path.expanduser(args.openclaw_home or "~/.openclaw"))
+    workspace = openclaw_root / f"workspace-{args.agent_name}"
+    agent_dir = openclaw_root / "agents" / args.agent_name / "agent"
+    model = resolve_model(args, current_agents if isinstance(current_agents, list) else [], openclaw_cmd, skip_current)
+    if not model:
+        raise RuntimeError("Missing model. Pass --model or ensure agents.defaults.model.primary exists.")
+
+    account_json = {
+        "name": args.agent_name,
+        "enabled": True,
+        "apiKey": args.api_key,
+        "wsUrl": args.api_endpoint,
+        "agentId": args.agent_id,
+    }
+
+    next_agents = []
+    replaced = False
+    for entry in current_agents if isinstance(current_agents, list) else []:
+        if str(entry.get("id") or "").strip() != args.agent_name:
+            next_agents.append(entry)
+            continue
+        replaced = True
+        updated = dict(entry)
+        updated["id"] = args.agent_name
+        updated["name"] = args.agent_name
+        updated["workspace"] = str(workspace)
+        updated["agentDir"] = str(agent_dir)
+        updated["model"] = model
+        next_agents.append(updated)
+    if not replaced:
+        next_agents.append(
+            {
+                "id": args.agent_name,
+                "name": args.agent_name,
+                "workspace": str(workspace),
+                "agentDir": str(agent_dir),
+                "model": model,
+            }
+        )
+
+    commands: list[list[str]] = [
+        [openclaw_cmd, "config", "set", f"channels.grix.accounts.{args.agent_name}", json.dumps(account_json, ensure_ascii=False), "--strict-json"],
+        [openclaw_cmd, "config", "set", "agents.list", json.dumps(next_agents, ensure_ascii=False), "--strict-json"],
+        [openclaw_cmd, "agents", "bind", "--agent", args.agent_name, "--bind", f"grix:{args.agent_name}", "--json"],
+        [openclaw_cmd, "config", "set", "tools.profile", json.dumps(str(current_profile or "coding")), "--strict-json"],
+        [openclaw_cmd, "config", "set", "tools.alsoAllow", json.dumps(merge_tool_allowlist(current_allow), ensure_ascii=False), "--strict-json"],
+        [openclaw_cmd, "config", "set", "tools.sessions.visibility", json.dumps(str(current_visibility or "agent")), "--strict-json"],
+    ]
+    if current_grix_enabled is False:
+        commands.append([openclaw_cmd, "config", "set", "channels.grix.enabled", "true", "--strict-json"])
+    commands.extend(
+        [
+            [openclaw_cmd, "config", "validate"],
+            [openclaw_cmd, "config", "get", f"channels.grix.accounts.{args.agent_name}", "--json"],
+            [openclaw_cmd, "config", "get", "agents.list", "--json"],
+            [openclaw_cmd, "agents", "bindings", "--agent", args.agent_name, "--json"],
+        ]
+    )
+
+    return {
+        "agent_name": args.agent_name,
+        "agent_id": args.agent_id,
+        "workspace": str(workspace),
+        "agent_dir": str(agent_dir),
+        "model": model,
+        "account": account_json,
+        "agents_list": next_agents,
+        "commands": commands,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Bind one Grix API agent into local OpenClaw config.")
+    parser.add_argument("--agent-name", required=True)
+    parser.add_argument("--agent-id", required=True)
+    parser.add_argument("--api-endpoint", required=True)
+    parser.add_argument("--api-key", required=True)
+    parser.add_argument("--model", default="")
+    parser.add_argument("--openclaw", default="openclaw")
+    parser.add_argument("--openclaw-home", default="")
+    parser.add_argument("--skip-current", action="store_true", help="Do not read current OpenClaw config before building the plan.")
+    parser.add_argument("--dry-run", action="store_true", help="Only print the planned result and commands.")
+    parser.add_argument("--json", action="store_true", help="Emit JSON summary.")
+    args = parser.parse_args()
+
+    try:
+        plan = build_plan(args)
+        created_files: list[str] = []
+        command_results: list[dict[str, Any]] = []
+        if not args.dry_run:
+            created_files = ensure_minimal_persona(Path(plan["workspace"]))
+            ensure_dir(Path(plan["agent_dir"]))
+            for cmd in plan["commands"]:
+                result = run_command(cmd)
+                command_results.append(
+                    {
+                        "cmd": cmd,
+                        "stdout": (result.stdout or "").strip(),
+                        "stderr": (result.stderr or "").strip(),
+                    }
+                )
+        payload = {
+            "ok": True,
+            "dry_run": bool(args.dry_run),
+            "created_files": created_files,
+            "command_results": command_results,
+            **plan,
+        }
+        if args.json:
+            print(json.dumps(payload, ensure_ascii=False, indent=2))
+        else:
+            print(f"agent={plan['agent_name']} workspace={plan['workspace']} dry_run={args.dry_run}")
+            for cmd in plan["commands"]:
+                print("$ " + " ".join(cmd))
+        return 0
+    except Exception as exc:  # noqa: BLE001
+        payload = {"ok": False, "error": str(exc)}
+        if args.json:
+            print(json.dumps(payload, ensure_ascii=False, indent=2), file=sys.stderr)
+        else:
+            print(str(exc), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())