robot-resources 1.11.0 → 1.11.2

package/README.md

@@ -1,88 +1,90 @@
-# Robot Resources
+# robot-resources
 
-> Tools for AI agents. Humans have HR. Agents have RR.
-
-Two products for any software that makes LLM API calls — chatbots, RAG pipelines, AI-powered apps, agent runtimes. Both run locally, both free.
-
-**Router** — Intelligent LLM routing proxy. Classifies each prompt by task type, routes to the cheapest model that qualifies. 60-90% cost savings with zero quality loss.
-
-**Scraper** — Token compression for web content. Fetches any URL, strips noise, returns clean markdown. Median 91% token reduction.
-
-## Install
+> One command to install Robot Resources tools for any agent stack.
 
 ```bash
 npx robot-resources
 ```
 
-One command: installs Router as an always-on system service, registers Scraper as an MCP tool, configures your agent automatically.
+The wizard detects what you're building and walks you through the right setup — OpenClaw plugin install, JS library path, Python SDK path, MCP config for Cursor / Claude Code, or just the docs URL.
 
-## What It Does
+## What the wizard does
 
-1. **Installs Router** — Python venv + system service on localhost:3838
-2. **Registers Scraper** — MCP tool `scraper_compress_url(url)` in your agent
-3. **Configures OpenClaw** — Plugin auto-installed if OpenClaw is detected
-4. **Provisions API key** — For telemetry and dashboard access
-5. **Health check** — Verifies everything is running after install
+1. **Provisions an anonymous API key** via `POST /v1/auth/signup` (saved to `~/.robot-resources/config.json`). Optional — routing works without it; the key just lights up the dashboard at robotresources.ai/dashboard.
+2. **Detects your stack**:
+   - OpenClaw installed (`~/.openclaw/`) → installs the router plugin (in-process HTTP server) + scraper OC plugin, patches `openclaw.json`, restarts the gateway. **No Python, no daemon, no system service.**
+   - Non-OC + cwd has `package.json` with LangChain/LangGraph/Mastra → preselects "JS/TS agent."
+   - Non-OC + cwd has `requirements.txt` / `pyproject.toml` → preselects "Python agent."
+   - Non-OC + Cursor or Claude Code installed → preselects "MCP tool."
+3. **Runs the chosen path**:
+   - **JS/TS agent** → prints `npm install @robot-resources/router` + `import { routePrompt }` example
+   - **Python agent** → prints `pip install robot-resources` + `from robot_resources.router import route` example, plus an httpx fallback if you'd rather skip the SDK
+   - **Cursor / Claude Code** → writes the scraper MCP config into `~/.cursor/mcp.json` / `~/.claude/settings.json`
+   - **Docs** → prints the URL + exits
+   - **Install OpenClaw first** → redirect message + exits
 
-## Router
+## Flags
 
-Transparent proxy on localhost:3838. Your LLM calls pass through, Router selects the cheapest capable model:
-
-- Hybrid classification: keyword detection (~5ms) + LLM fallback (~200ms)
-- Dynamic thresholds: simple tasks → cheap models, complex tasks → top models
-- Models across OpenAI, Anthropic, Google — routes within your available providers
-- Your API keys pass through via headers — never stored by Router
-- OpenAI-compatible API — change `base_url` to `http://localhost:3838`
+```
+--for=<target>      langchain | python | cursor | claude-code | docs
+                    Skip the prompt and run that path directly.
+                    Required for non-TTY contexts (CI, piped, etc.)
+--non-interactive   Treat as CI run regardless of TTY state
+--yes / -y          Same as --non-interactive
+```
 
-## Scraper
+Without flags in a non-TTY context, the wizard prints the `--for=` hint and exits cleanly — never blocks waiting for stdin.
 
-Available as MCP tool after install:
+## Pre-set the API key
 
-- Mozilla Readability extraction (0.97 F1 accuracy)
-- Content-aware token estimation
-- 3-tier fetch: fast, stealth (TLS fingerprint), render (headless browser)
-- Multi-page BFS crawl with robots.txt compliance
-- Median 91% token reduction per page
+For fleets or CI:
 
-## Agent Compatibility
+```bash
+export RR_API_KEY=rr_live_...        # skip signup, use this key
+npx robot-resources --for=cursor     # or whatever path applies
+```
 
-| Agent | Integration | Status |
-|-------|-------------|--------|
-| **OpenClaw** | Plugin (auto-install) | Verified |
-| **Claude Code** | MCP server | Verified |
-| **Any OpenAI client** | HTTP proxy (localhost:3838) | Compatible |
-| **Cursor** | MCP server | Compatible |
-| **Windsurf** | MCP server | Compatible |
+## Five paths, one wizard
 
-## MCP Servers
+| Path | What you get | Where |
+|---|---|---|
+| OpenClaw plugin | In-process router inside the OC gateway. Auto-routes Anthropic calls to the cheapest capable model. | `~/.openclaw/extensions/robot-resources-router/` |
+| JS/TS agent | `@robot-resources/router/routing` — pure ESM, zero deps, offline keyword classifier. | npm |
+| Python agent | `robot-resources` (singular) — thin httpx client over `/v1/route`. | PyPI |
+| HTTP API | Any language with curl/fetch. Authed by API key. | `POST https://api.robotresources.ai/v1/route` |
+| Cursor / Claude Code MCP | Scraper MCP wired into your tool's config (web fetches → 91% smaller markdown). | `~/.cursor/mcp.json` or `~/.claude/settings.json` |
 
-```bash
-npx -y @robot-resources/scraper-mcp   # Scraper compression
-```
+Full integration docs: https://robotresources.ai/docs
 
-## Dashboard
+## Architecture (post-PR-2.5)
 
-Usage dashboard at https://robotresources.ai/dashboard — real-time telemetry, cost savings, routing stats. Auth via GitHub OAuth.
+The router used to be a Python daemon on `localhost:3838`. **Not anymore.** It now runs in-process inside whichever surface consumes it:
 
-## Pricing
+- **OpenClaw** — the plugin's `register()` starts an HTTP server on `127.0.0.1:18790` inside OC's node process. Lifetime tied to OC. Zero daemon to keep alive.
+- **JS agents** — call `routePrompt()` directly. No HTTP at all. Pure function.
+- **Python / curl** — call `POST /v1/route` on `api.robotresources.ai`. Server-side classifier on Cloudflare Workers.
 
-Free. Unlimited. No tiers. Your API keys never leave your machine.
+User provider keys never leave the user's machine. The platform never receives, stores, or transmits them.
 
 ## Telemetry
 
-Anonymous usage telemetry (model selection, cost savings) to improve the product. No personal data, no request content, no API keys.
+Anonymous, fire-and-forget, opt-in via the wizard's API-key provisioning. Events: `wizard_started`, `wizard_path_chosen`, `install_complete`, `route_completed`, `route_via_api`, `route_via_lib`. No personal data, no request content, no provider keys.
 
-Opt out: `export RR_TELEMETRY=off`
+## Pricing
+
+Free. Unlimited. Your API keys never leave your machine.
 
 ## Links
 
 - Website: https://robotresources.ai
+- Docs: https://robotresources.ai/docs
 - Dashboard: https://robotresources.ai/dashboard
-- Agent docs: https://robotresources.ai/llms.txt
+- HTTP API: `POST https://api.robotresources.ai/v1/route`
 - npm: https://www.npmjs.com/package/robot-resources
 - GitHub: https://github.com/robot-resources/packages
 - Discord: https://robotresources.ai/discord
 - Contact: agent@robotresources.ai
+- Agent docs: https://robotresources.ai/llms.txt
 
 ## License
 

package/bin/setup.js

@@ -1,20 +1,32 @@
 #!/usr/bin/env node
 
-import { runWizard } from '../lib/wizard.js';
+import { runWizard, runUninstallCommand } from '../lib/wizard.js';
 
 const args = process.argv.slice(2);
-const explicitNonInteractive =
-  args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
-const targetArg = args.find((a) => a.startsWith('--for='));
-const target = targetArg ? targetArg.slice('--for='.length) : null;
 
-// Treat piped/CI runs (no TTY on stdin OR stdout) as non-interactive so the
-// wizard never blocks on a prompt that can't be answered. The interactive
-// menu is only opened when both stdin and stdout are real terminals.
-const hasTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-const nonInteractive = explicitNonInteractive || !hasTty;
+// --uninstall ships in Phase 0 as the counterpart to install. --purge also
+// wipes ~/.robot-resources/config.json (api_key + claim_url); without it,
+// the api_key is preserved across a reinstall.
+if (args.includes('--uninstall')) {
+  const purge = args.includes('--purge');
+  runUninstallCommand({ purge }).catch((err) => {
+    console.error(`\n  ✗ Uninstall failed: ${err.message}\n`);
+    process.exit(1);
+  });
+} else {
+  const explicitNonInteractive =
+    args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
+  const targetArg = args.find((a) => a.startsWith('--for='));
+  const target = targetArg ? targetArg.slice('--for='.length) : null;
 
-runWizard({ nonInteractive, target }).catch((err) => {
-  console.error(`\n  ✗ Setup failed: ${err.message}\n`);
-  process.exit(1);
-});
+  // Treat piped/CI runs (no TTY on stdin OR stdout) as non-interactive so the
+  // wizard never blocks on a prompt that can't be answered. The interactive
+  // menu is only opened when both stdin and stdout are real terminals.
+  const hasTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const nonInteractive = explicitNonInteractive || !hasTty;
+
+  runWizard({ nonInteractive, target }).catch((err) => {
+    console.error(`\n  ✗ Setup failed: ${err.message}\n`);
+    process.exit(1);
+  });
+}

package/lib/non-oc-wizard.js

@@ -108,14 +108,17 @@ function showPythonPath() {
   success('Python integration');
   blank();
   info('Install:');
-  info('  pip install robot-resources-router');
+  info('  pip install robot-resources');
   blank();
   info('Use:');
-  info('  from rr_router import route');
+  info('  from robot_resources.router import route');
   info('  decision = route(\'write a python function\')');
   info('  print(decision[\'selected_model\'])  # e.g. \'claude-haiku-4-5\'');
   blank();
-  info('Full docs: https://robotresources.ai/docs/python');
+  info('Prefer no SDK? POST directly to https://api.robotresources.ai/v1/route');
+  info('with httpx / requests / any HTTP client. See docs.');
+  blank();
+  info('Full docs: https://robotresources.ai/docs/crewai');
   blank();
 }
 
@@ -156,7 +159,7 @@ function showDocsPath() {
   blank();
   info('Integration guides: https://robotresources.ai/docs');
   info('HTTP API:          https://robotresources.ai/docs/http-api');
-  info('GitHub:            https://github.com/robot-resources/robot-resources');
+  info('GitHub:            https://github.com/robot-resources/packages');
   blank();
 }
 
@@ -203,6 +206,7 @@ export async function runNonOcWizard({ nonInteractive = false, target = null } =
     info('  npx robot-resources --for=claude-code    # Claude Code MCP config');
     info('  npx robot-resources --for=docs           # docs URL');
     blank();
+    await emitPathChosen('noninteractive_no_target');
     return;
   }
 
@@ -228,8 +232,13 @@ export async function runNonOcWizard({ nonInteractive = false, target = null } =
       ],
     });
   } catch (err) {
-    // User hit Ctrl-C or terminal closed — exit cleanly.
-    if (err && (err.name === 'ExitPromptError' || err.code === 'ABORT_ERR')) return;
+    // User hit Ctrl-C or terminal closed — exit cleanly, but mark the funnel
+    // so we can distinguish "agent shown the prompt and bailed" from
+    // "wizard never reached the prompt at all" in Supabase.
+    if (err && (err.name === 'ExitPromptError' || err.code === 'ABORT_ERR')) {
+      await emitPathChosen('aborted');
+      return;
+    }
     throw err;
   }
 

package/lib/tool-config.js

@@ -301,7 +301,7 @@ function configureOpenClaw() {
       );
     }
 
-    instructions.push('Docs: https://github.com/robot-resources/robot-resources');
+    instructions.push('Docs: https://github.com/robot-resources/packages');
 
     return {
       name: 'OpenClaw',
@@ -339,7 +339,7 @@ function printManualInstructions() {
       '  #   OpenAI(base_url="http://localhost:3838/v1")',
       '  #   model = "gemini-2.5-flash"',
       '',
-      'Docs: https://github.com/robot-resources/robot-resources',
+      'Docs: https://github.com/robot-resources/packages',
     ],
   };
 }

package/lib/uninstall.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { stripJson5 } from './json5.js';
+
+/**
+ * Single source of truth for `npx robot-resources --uninstall`.
+ *
+ * Reverses the install actions in tool-config.js: removes the router and
+ * scraper OC plugin directories, deletes their entries from openclaw.json
+ * (plugins.entries + plugins.allow + mcp.servers).
+ *
+ * Phase 0 scope is OC-only. Phase 3 will extend this with shell-config
+ * removal (NODE_OPTIONS line) and `pip uninstall robot-resources` for the
+ * Node and Python shim install paths.
+ *
+ * `~/.robot-resources/config.json` is preserved by default so a subsequent
+ * re-install reuses the same api_key (and the user's claim_url stays valid).
+ * Pass { purge: true } to wipe it as well.
+ *
+ * Returns { components_removed: string[], errors: { component, message }[] }
+ * for telemetry. Failure to remove one component never aborts the others —
+ * a partial uninstall is still progress, and we want to record what worked.
+ */
+export function runUninstall({ purge = false } = {}) {
+  const components_removed = [];
+  const errors = [];
+
+  // 1. Plugin directories under ~/.openclaw/extensions/
+  const pluginDirs = [
+    { id: 'robot-resources-router', label: 'router_plugin_dir' },
+    { id: 'robot-resources-scraper-oc-plugin', label: 'scraper_plugin_dir' },
+  ];
+  for (const { id, label } of pluginDirs) {
+    const path = join(homedir(), '.openclaw', 'extensions', id);
+    if (!existsSync(path)) continue;
+    try {
+      rmSync(path, { recursive: true, force: true });
+      components_removed.push(label);
+    } catch (err) {
+      errors.push({ component: label, message: err.message });
+    }
+  }
+
+  // 2. openclaw.json — strip our entries from plugins.entries, plugins.allow,
+  //    and mcp.servers. Leave everything else (other plugins, user config) alone.
+  //    Idempotent: if openclaw.json is missing or malformed, skip silently —
+  //    that's the right behavior for "cleanup what you can find."
+  const ocConfigPath = join(homedir(), '.openclaw', 'openclaw.json');
+  if (existsSync(ocConfigPath)) {
+    try {
+      const config = JSON.parse(stripJson5(readFileSync(ocConfigPath, 'utf-8')));
+      let mutated = false;
+
+      if (config?.plugins?.entries) {
+        for (const id of ['robot-resources-router', 'robot-resources-scraper-oc-plugin']) {
+          if (config.plugins.entries[id]) {
+            delete config.plugins.entries[id];
+            mutated = true;
+          }
+        }
+      }
+
+      if (Array.isArray(config?.plugins?.allow)) {
+        const before = config.plugins.allow.length;
+        config.plugins.allow = config.plugins.allow.filter(
+          (id) => id !== 'robot-resources-router' && id !== 'robot-resources-scraper-oc-plugin',
+        );
+        if (config.plugins.allow.length !== before) mutated = true;
+      }
+
+      if (config?.mcp?.servers?.['robot-resources-scraper']) {
+        delete config.mcp.servers['robot-resources-scraper'];
+        mutated = true;
+      }
+
+      if (mutated) {
+        writeFileSync(ocConfigPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        components_removed.push('openclaw_config_entries');
+      }
+    } catch (err) {
+      errors.push({ component: 'openclaw_config_entries', message: err.message });
+    }
+  }
+
+  // 3. Optionally wipe ~/.robot-resources/config.json (and any siblings)
+  if (purge) {
+    const rrDir = join(homedir(), '.robot-resources');
+    if (existsSync(rrDir)) {
+      try {
+        rmSync(rrDir, { recursive: true, force: true });
+        components_removed.push('rr_config_dir');
+      } catch (err) {
+        errors.push({ component: 'rr_config_dir', message: err.message });
+      }
+    }
+  }
+
+  return { components_removed, errors };
+}

package/lib/wizard.js

@@ -8,6 +8,7 @@ import { configureToolRouting, registerScraperMcp, restartOpenClawGateway } from
 import { checkHealth } from './health-report.js';
 import { header, step, success, warn, error, info, blank, summary } from './ui.js';
 import { runNonOcWizard } from './non-oc-wizard.js';
+import { runUninstall } from './uninstall.js';
 
 // Stamped onto every CLI telemetry payload so we can tell which `robot-resources`
 // version a user actually ran. Without this, npx-cached old installers look
@@ -45,24 +46,17 @@ const CLI_VERSION = (() => {
 export async function runWizard({ nonInteractive = false, target = null } = {}) {
   header();
 
-  // Non-OC branch. Hands off to the multi-agent compatibility wizard which
-  // routes the user to the right install path (npm install / pip install /
-  // MCP config / docs / install-OC). Non-interactive callers bypass into the
-  // OC install path only when --for=<target> isn't supplied; otherwise they
-  // get the print-and-exit hint with the supported --for= options.
-  // Pre-PR-8 this was a 17-line print-and-exit; PR 8 made it interactive.
-  if (!isOpenClawInstalled()) {
-    await runNonOcWizard({ nonInteractive, target });
-    return;
-  }
-
+  // Detect OC once up front. Used both to branch into the non-OC wizard and
+  // to tag the wizard_started payload, so the funnel can be segmented OC vs
+  // non-OC without a second event type.
+  const openclawDetected = isOpenClawInstalled();
   const wizardStartMs = Date.now();
 
   const results = {
     auth: false,
     authMethod: null, // 'config' | 'apikey' | 'auto'
     pluginInstalled: false,
-    openclawDetected: false,
+    openclawDetected,
     openclawConfigPatched: false,
     scraperMcpRegistered: false,
     scraper: false,
@@ -70,9 +64,11 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
 
   // ── Step 0: Provision API key (before anything else) ────────────────────
   //
-  // Provision early so config.json exists before any tool installs.
-  // If the session dies later, telemetry still works for all tools.
-  // Single fetch() with 10s timeout — no prompts, no browser.
+  // Runs for BOTH the OC and non-OC paths. Provisioning before the non-OC
+  // hand-off closes the funnel blind spot where every non-OpenClaw install
+  // was invisible to telemetry (no api_keys row, no wizard_started, no
+  // agent_signup_meta). If the session dies later, telemetry still works
+  // for all tools. Single fetch() with 10s timeout — no prompts, no browser.
 
   {
     const config = readConfig();
@@ -116,10 +112,11 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
 
   // ── Funnel marker: wizard_started ───────────────────────────────────────
   //
-  // Sent immediately after auth so we have proof the wizard reached this
-  // point even if any install step crashes. Pairs with install_complete at
-  // the end to give us a "started → completed" funnel for diagnosing silent
-  // signups. Fire-and-forget — never fatal.
+  // Sent immediately after auth, before either path branches, so we have
+  // proof the wizard reached this point even if a later step crashes. Pairs
+  // with install_complete (OC path) or wizard_path_chosen (non-OC path) to
+  // give us a "started → done" funnel. The openclaw_detected field lets us
+  // segment OC vs non-OC funnels without a second event type.
   //
   // Timeout asymmetry vs install_complete (5s, no retry vs 10s × 2 attempts):
   // wizard_started is a best-effort funnel marker — losing it just means we
@@ -144,6 +141,7 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
             cli_version: CLI_VERSION,
             auth_method: results.authMethod,
             non_interactive: nonInteractive,
+            openclaw_detected: openclawDetected,
           },
         }),
         signal: AbortSignal.timeout(5_000),
@@ -153,6 +151,15 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
     }
   }
 
+  // Non-OC branch. Hands off to the multi-agent compatibility wizard which
+  // routes the user to the right install path (npm install / pip install /
+  // MCP config / docs / install-OC). The non-OC wizard's wizard_path_chosen
+  // telemetry now fires too, since Step 0 above provisioned an api_key.
+  if (!openclawDetected) {
+    await runNonOcWizard({ nonInteractive, target });
+    return;
+  }
+
   // ── Step 1: Tool Routing Configuration ──────────────────────────────────
   //
   // Installs the OC plugin (which is @robot-resources/router — the router
@@ -166,7 +173,6 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
   const toolResults = configureToolRouting();
   results.tools = toolResults;
 
-  results.openclawDetected = isOpenClawInstalled();
   const ocResult = toolResults.find((r) => r.name === 'OpenClaw');
   if (ocResult) {
     results.pluginInstalled =
@@ -384,7 +390,7 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
   // Telegram survives this restart. If the session dies here, the agent
   // picks up on the next message with all tools loaded.
 
-  if (isOpenClawInstalled() && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
+  if (openclawDetected && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
     try {
       await restartOpenClawGateway();
       success('OpenClaw gateway restarted');
@@ -393,3 +399,71 @@ export async function runWizard({ nonInteractive = false, target = null } = {})
     }
   }
 }
+
+/**
+ * Uninstall counterpart to runWizard. Removes the OC plugin install side
+ * (router + scraper plugin dirs, openclaw.json entries) via uninstall.js.
+ *
+ * config.json (and its api_key) is preserved by default so a later re-install
+ * keeps the same identity. `--purge` wipes ~/.robot-resources/ as well.
+ *
+ * Telemetry: emits `wizard_uninstalled` with the list of components actually
+ * removed plus any per-component errors. Fire-and-forget — never block the
+ * uninstall on telemetry latency or failure.
+ */
+export async function runUninstallCommand({ purge = false } = {}) {
+  header();
+  step(purge ? 'Uninstalling Robot Resources (purge)...' : 'Uninstalling Robot Resources...');
+
+  const result = runUninstall({ purge });
+
+  blank();
+  if (result.components_removed.length === 0 && result.errors.length === 0) {
+    info('Nothing to remove — Robot Resources was not installed in this account.');
+  } else {
+    if (result.components_removed.length > 0) {
+      success(`Removed: ${result.components_removed.join(', ')}`);
+    }
+    for (const e of result.errors) {
+      warn(`${e.component}: ${e.message}`);
+    }
+  }
+
+  // Preserve the api_key (unless --purge) so re-running `npx robot-resources`
+  // doesn't issue a second key. Tell the user explicitly so they can purge if
+  // they really want a clean slate.
+  if (!purge) {
+    blank();
+    info('Kept ~/.robot-resources/config.json (your api_key + claim_url).');
+    info('Re-run with --purge to wipe it.');
+  }
+
+  // Best-effort telemetry — same shape as the rest of the CLI's calls.
+  try {
+    const config = readConfig();
+    if (config.api_key) {
+      const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+      await fetch(`${platformUrl}/v1/telemetry`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${config.api_key}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          product: 'cli',
+          event_type: 'wizard_uninstalled',
+          payload: {
+            cli_version: CLI_VERSION,
+            purge,
+            components_removed: result.components_removed,
+            error_count: result.errors.length,
+            platform: process.platform,
+          },
+        }),
+        signal: AbortSignal.timeout(5_000),
+      });
+    }
+  } catch {
+    // Non-fatal — telemetry must never block the uninstall path.
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robot-resources",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "Robot Resources — AI agent tools. One command to install everything.",
   "type": "module",
   "bin": {
@@ -46,7 +46,7 @@
   },
   "homepage": "https://robotresources.ai",
   "bugs": {
-    "url": "https://github.com/robot-resources/robot-resources/issues"
+    "url": "https://github.com/robot-resources/packages/issues"
   },
   "publishConfig": {
     "access": "public"