@wipcomputer/universal-installer 2.1.1

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+
+
+## 2.1.1 (2026-02-21)
+
+Add Universal Interface badges, agent-driven install prompt, fix description
+
+## 2.1.0 (2026-02-21)
+
+Rename Six Doors to Universal Interface. Update all code and docs.
+
+## 2.0.0 (2026-02-20)
+
+Major refactor. Reframed from "WIP Computer installer" to "the spec for agent-native software."
+
+### Added
+- `detect.mjs` ... importable door detection module
+- `SPEC.md` ... formal Six Doors specification
+- `--dry-run` flag ... detect doors without installing
+- `--json` flag ... machine-readable detection output
+- `LICENSE` (MIT)
+- `SKILL.md` with agent instructions
+- `examples/minimal/` ... minimal six-door template
+
+### Changed
+- README rewritten around Karpathy's sensor/actuator argument
+- `install.mjs` now imports detection logic from `detect.mjs`
+- Package name updated: `@wipcomputer/universal-installer`
+
+## 1.0.0 (2026-02-17)
+
+Initial release. Universal installer for WIP.computer repos.
+
+- Detects 6 door types: CLI, Module, MCP, OpenClaw, Skill, CC Hook
+- Installs from GitHub URL, org/repo shorthand, or local path
+- Supports any WIP.computer convention repo

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parker Todd Brooks
+
+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,176 @@
+###### WIP Computer
+
+[![npm](https://img.shields.io/npm/v/@wipcomputer/universal-installer)](https://www.npmjs.com/package/@wipcomputer/universal-installer) [![CLI / TUI](https://img.shields.io/badge/interface-CLI_/_TUI-black)](https://github.com/wipcomputer/wip-universal-installer/blob/main/install.mjs) [![OpenClaw Skill](https://img.shields.io/badge/interface-OpenClaw_Skill-black)](https://clawhub.ai/parkertoddbrooks/wip-universal-installer) [![Claude Code Skill](https://img.shields.io/badge/interface-Claude_Code_Skill-black)](https://github.com/wipcomputer/wip-universal-installer/blob/main/SKILL.md) [![Universal Interface Spec](https://img.shields.io/badge/Universal_Interface_Spec-black?style=flat&color=black)](https://github.com/wipcomputer/wip-universal-installer/blob/main/SPEC.md)
+
+# Universal Installer
+
+Here's how to build software in 2026.
+
+## The Problem
+
+Most software is built for humans. GUIs, dashboards, web apps. Humans click buttons, fill forms, read screens.
+
+But the users are changing. AI agents are the new users. They don't click. They call functions. They read instructions. They compose tools. They need a **universal interface** ... multiple ways into the same logic, native to however the consumer works.
+
+Software built for humans doesn't work for agents. And software built only for agents doesn't work for humans. You need both.
+
+## The Karpathy Argument
+
+Andrej Karpathy put it clearly:
+
+> "I think the app store, the move to mobile, the concept of an app ... is an increasingly outdated concept. What matters are sensors and actuators. Sensors are things that convert physical state into digital state. Actuators are things that convert digital intent into physical change."
+>
+> "All LLMs care about are tools and the tools fall into this sensor/actuator divide. Software shouldn't be built into apps, but into small bespoke tools. Apps are for people. Tools are for LLMs, and increasingly, LLMs are the ones using software."
+
+[Source](https://x.com/karpathy/status/2024583544157458452)
+
+This is the future of software. Not apps. Tools. Sensors and actuators that agents compose together.
+
+## Sensors and Actuators
+
+Every tool is a sensor, an actuator, or both:
+
+**Sensors** convert state into data:
+- Search the web (wip-grok search_web)
+- Search X/Twitter (wip-grok search_x, wip-x search_recent)
+- Fetch a post (wip-x fetch_post)
+- Read bookmarks (wip-x get_bookmarks)
+- Check system health (wip-healthcheck)
+
+**Actuators** convert intent into action:
+- Generate an image (wip-grok generate_image)
+- Post a tweet (wip-x post_tweet)
+- Guard a file from edits (wip-file-guard)
+- Generate a video (wip-grok generate_video)
+
+## The Universal Interface
+
+Agents don't all speak the same language. Some run shell commands. Some import modules. Some talk MCP. Some read markdown instructions.
+
+So every tool should expose multiple interfaces into the same core logic:
+
+| Interface | What | Who uses it |
+|-----------|------|-------------|
+| **CLI** | Shell command | Humans, any agent with bash |
+| **Module** | ES import | Other tools, scripts |
+| **MCP Server** | JSON-RPC over stdio | Claude Code, Cursor, any MCP client |
+| **OpenClaw Plugin** | Lifecycle hooks + tools | OpenClaw agents |
+| **Skill** | Markdown instructions (SKILL.md) | Any agent that reads files |
+| **Claude Code Hook** | PreToolUse/Stop events | Claude Code |
+
+Not every tool needs all six. Build what makes sense. But the more interfaces you expose, the more agents can use your tool.
+
+See [SPEC.md](SPEC.md) for the full specification.
+
+## How to Build It
+
+The architecture is simple. Four files:
+
+```
+your-tool/
+  core.mjs            <- pure logic, zero deps if possible
+  cli.mjs             <- thin CLI wrapper
+  mcp-server.mjs      <- MCP server wrapping core as tools
+  SKILL.md            <- when/how to use it, for agents
+```
+
+`core.mjs` does the work. Everything else is a thin wrapper. CLI parses argv and calls core. MCP server maps tools to core functions. SKILL.md teaches agents when to call what.
+
+This means one codebase, one set of tests, multiple interfaces.
+
+## The Reference Installer
+
+`wip-install` scans any repo, detects which interfaces exist, and installs them all. One command.
+
+```bash
+# From GitHub
+wip-install wipcomputer/wip-grok
+
+# From a local path
+wip-install /path/to/repo
+
+# Detect only (no install)
+wip-install --dry-run wipcomputer/wip-x
+
+# Machine-readable output
+wip-install --json /path/to/repo
+```
+
+### Example Output
+
+```
+  Installing: wip-grok
+  ────────────────────────────────────────
+  Detected 4 interface(s): cli, module, mcp, skill
+
+  ✓ CLI: wip-grok installed globally
+  ✓ Module: import from "core.mjs"
+  MCP Server detected: mcp-server.mjs
+  ✓ Skill: SKILL.md available
+
+  Done. 4 interface(s) processed.
+```
+
+### What It Detects
+
+| Pattern | Interface | Install action |
+|---------|-----------|---------------|
+| `package.json` with `bin` | CLI | `npm install -g` |
+| `main` or `exports` in `package.json` | Module | Reports import path |
+| `mcp-server.mjs` | MCP | Prints `.mcp.json` config |
+| `openclaw.plugin.json` | OpenClaw | Copies to `~/.openclaw/extensions/` |
+| `SKILL.md` | Skill | Reports path |
+| `guard.mjs` or `claudeCode.hook` | CC Hook | Adds to `~/.claude/settings.json` |
+
+## Install
+
+Open your AI coding tool and say:
+
+```
+Read the SPEC.md and SKILL.md at github.com/wipcomputer/wip-universal-installer.
+Then explain to me:
+1. What is this tool?
+2. What does it do?
+3. What would it change or fix in our current system?
+
+Then ask me:
+- Do you have more questions?
+- Do you want to integrate it into our system?
+- Do you want to clone it (use as-is) or fork it (so you can contribute back if you find bugs)?
+```
+
+Your agent will read the repo, explain the tool, and walk you through integration interactively.
+
+Also see **[wip-release](https://github.com/wipcomputer/wip-release)** ... one-command release pipeline for agent-native software.
+
+See [SPEC.md](SPEC.md) for the full Universal Interface specification.
+
+## Real Examples
+
+| Tool | Type | Interfaces | What it does |
+|------|------|------------|-------------|
+| [wip-grok](https://github.com/wipcomputer/wip-grok) | Sensor + Actuator | CLI + Module + MCP + Skill | xAI Grok API: search web/X, generate images/video |
+| [wip-x](https://github.com/wipcomputer/wip-x) | Sensor + Actuator | CLI + Module + MCP + Skill | X Platform API: read/write tweets, bookmarks |
+| [wip-file-guard](https://github.com/wipcomputer/wip-file-guard) | Actuator | CLI + OpenClaw + CC Hook | Protect files from AI edits |
+| [wip-healthcheck](https://github.com/wipcomputer/wip-healthcheck) | Sensor | CLI + Module | System health monitoring |
+
+## Supported Tools
+
+Works with any AI agent or coding tool that can run shell commands:
+
+| Tool | How |
+|------|-----|
+| Claude Code | CLI via bash, hooks via settings.json, MCP via .mcp.json |
+| OpenAI Codex CLI | CLI via bash, skills via AGENTS.md |
+| Cursor | CLI via terminal, MCP via config |
+| Windsurf | CLI via terminal, MCP via config |
+| OpenClaw | Plugins, skills, MCP |
+| Any agent | CLI works everywhere. If it has a shell, it works. |
+
+---
+
+## License
+
+MIT
+
+Built by Parker Todd Brooks, with Claude Code and Lēsa (OpenClaw).

package/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: wip-universal-installer
+version: 2.1.1
+description: Reference installer for agent-native software. Detects and installs all interfaces from any repo.
+homepage: https://github.com/wipcomputer/wip-universal-installer
+metadata:
+  category: dev-tools
+  capabilities:
+    - detect-interfaces
+    - install-cli
+    - install-mcp
+    - install-openclaw-plugin
+    - install-claude-code-hook
+  dependencies: []
+  interface: CLI
+openclaw:
+  emoji: "🔌"
+  install:
+    env: []
+author:
+  name: Parker Todd Brooks
+---
+
+# wip-universal-installer
+
+Reference installer for agent-native software. Scans a repo, detects which interfaces it exposes, and installs them all.
+
+## When to Use This Skill
+
+**Use wip-install for:**
+- Installing any repo that follows the Universal Interface pattern
+- Detecting what interfaces a repo provides
+- Setting up CLI tools, MCP servers, OpenClaw plugins, and Claude Code hooks in one command
+
+**Use detect.mjs for:**
+- Programmatically detecting interfaces in a repo
+- Building custom installers or CI pipelines
+- Validating that a repo follows the spec
+
+### Do NOT Use For
+
+- Installing standard npm packages (use npm directly)
+- Repos that don't follow the Universal Interface conventions
+- Building or compiling code (this only installs)
+
+## API Reference
+
+### CLI
+
+```bash
+wip-install /path/to/repo           # install all interfaces
+wip-install org/repo                 # clone from GitHub + install
+wip-install --dry-run /path/to/repo  # detect only, no changes
+wip-install --json /path/to/repo     # JSON output
+```
+
+### Module (detect.mjs)
+
+```javascript
+import { detectInterfaces, describeInterfaces, detectInterfacesJSON } from './detect.mjs';
+
+const { interfaces, pkg } = detectInterfaces('/path/to/repo');
+console.log(describeInterfaces(interfaces));
+
+const json = detectInterfacesJSON('/path/to/repo');
+console.log(JSON.stringify(json, null, 2));
+```
+
+## Universal Interface
+
+See [SPEC.md](https://github.com/wipcomputer/wip-universal-installer/blob/main/SPEC.md) for the full specification.
+
+1. **CLI** ... `package.json` bin field
+2. **Module** ... `package.json` main/exports
+3. **MCP Server** ... `mcp-server.mjs`
+4. **OpenClaw Plugin** ... `openclaw.plugin.json`
+5. **Skill** ... `SKILL.md`
+6. **Claude Code Hook** ... `guard.mjs` or `claudeCode.hook`

package/SPEC.md

@@ -0,0 +1,161 @@
+# The Universal Interface Specification
+
+Every tool is a sensor, an actuator, or both. Every tool should be accessible through multiple interfaces. We call this the Universal Interface.
+
+This is the spec.
+
+## The Six Interfaces
+
+### 1. CLI
+
+A shell command. The most universal interface. If it has a terminal, it works.
+
+**Convention:** `package.json` with a `bin` field.
+
+**Detection:** `pkg.bin` exists.
+
+**Install:** `npm install -g .` or `npm link`.
+
+```json
+{
+  "bin": {
+    "wip-grok": "./cli.mjs"
+  }
+}
+```
+
+### 2. Module
+
+An importable ES module. The programmatic interface. Other tools compose with it.
+
+**Convention:** `package.json` with `main` or `exports` field. File is `core.mjs` by convention.
+
+**Detection:** `pkg.main` or `pkg.exports` exists.
+
+**Install:** `npm install <package>` or import directly from path.
+
+```json
+{
+  "type": "module",
+  "main": "core.mjs",
+  "exports": {
+    ".": "./core.mjs",
+    "./cli": "./cli.mjs"
+  }
+}
+```
+
+### 3. MCP Server
+
+A JSON-RPC server implementing the Model Context Protocol. Any MCP-compatible agent can use it.
+
+**Convention:** `mcp-server.mjs` (or `.js`, `.ts`) at the repo root. Uses `@modelcontextprotocol/sdk`.
+
+**Detection:** One of `mcp-server.mjs`, `mcp-server.js`, `mcp-server.ts`, `dist/mcp-server.js` exists.
+
+**Install:** Add to `.mcp.json`:
+
+```json
+{
+  "tool-name": {
+    "command": "node",
+    "args": ["/path/to/mcp-server.mjs"]
+  }
+}
+```
+
+### 4. OpenClaw Plugin
+
+A plugin for OpenClaw agents. Lifecycle hooks, tool registration, settings.
+
+**Convention:** `openclaw.plugin.json` at the repo root.
+
+**Detection:** `openclaw.plugin.json` exists.
+
+**Install:** Copy to `~/.openclaw/extensions/<name>/`, run `npm install --omit=dev`.
+
+### 5. Skill (SKILL.md)
+
+A markdown file that teaches agents when and how to use the tool. The instruction interface.
+
+**Convention:** `SKILL.md` at the repo root. YAML frontmatter with name, version, description, metadata.
+
+**Detection:** `SKILL.md` exists.
+
+**Install:** Referenced by path. Agents read it when they need the tool.
+
+```yaml
+---
+name: wip-grok
+version: 1.0.0
+description: xAI Grok API. Search the web, search X, generate images.
+metadata:
+  category: search,media
+  capabilities:
+    - web-search
+    - image-generation
+---
+```
+
+### 6. Claude Code Hook
+
+A hook that runs during Claude Code's tool lifecycle (PreToolUse, Stop, etc.).
+
+**Convention:** `guard.mjs` at repo root, or `claudeCode.hook` in `package.json`.
+
+**Detection:** `guard.mjs` exists, or `pkg.claudeCode.hook` is defined.
+
+**Install:** Added to `~/.claude/settings.json` under `hooks`.
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Edit|Write",
+      "hooks": [{
+        "type": "command",
+        "command": "node /path/to/guard.mjs",
+        "timeout": 5
+      }]
+    }]
+  }
+}
+```
+
+## Architecture
+
+Every repo that follows this spec has the same basic structure:
+
+```
+your-tool/
+  core.mjs            pure logic, zero or minimal deps
+  cli.mjs             thin CLI wrapper around core
+  mcp-server.mjs      MCP server wrapping core functions as tools
+  SKILL.md            agent instructions with YAML frontmatter
+  package.json         name, bin, main, exports, type: module
+  README.md            human documentation
+```
+
+Not every tool needs all six interfaces. Build the ones that make sense.
+
+The minimum viable agent-native tool has two interfaces: **Module** (importable) and **Skill** (agent instructions). Add CLI for humans. Add MCP for agents that speak MCP. Add OpenClaw/CC Hook for specific platforms.
+
+## The Reference Installer
+
+`wip-install` is the reference implementation. It scans a repo, detects which interfaces exist, and installs them all. One command.
+
+```bash
+wip-install /path/to/repo          # local
+wip-install org/repo               # from GitHub
+wip-install --dry-run /path/to/repo # detect only
+wip-install --json /path/to/repo    # JSON output
+```
+
+## Examples
+
+| Repo | Interfaces | Type |
+|------|------------|------|
+| [wip-grok](https://github.com/wipcomputer/wip-grok) | CLI + Module + MCP + Skill | Sensor + Actuator |
+| [wip-x](https://github.com/wipcomputer/wip-x) | CLI + Module + MCP + Skill | Sensor + Actuator |
+| [wip-file-guard](https://github.com/wipcomputer/wip-file-guard) | CLI + OpenClaw + CC Hook | Actuator |
+| [wip-markdown-viewer](https://github.com/wipcomputer/wip-markdown-viewer) | CLI + Module | Actuator |

package/detect.mjs

@@ -0,0 +1,112 @@
+/**
+ * wip-universal-installer/detect.mjs
+ * Interface detection logic. Scans a repo and reports which interfaces it exposes.
+ * Importable by other tools. Zero dependencies.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect all interfaces in a repo.
+ * Returns { interfaces, pkg } where interfaces is an object keyed by interface type.
+ */
+export function detectInterfaces(repoPath) {
+  const interfaces = {};
+  const pkg = readJSON(join(repoPath, 'package.json'));
+
+  // 1. CLI: package.json has bin entry
+  if (pkg?.bin) {
+    interfaces.cli = { bin: pkg.bin, name: pkg.name };
+  }
+
+  // 2. Module: package.json has main or exports
+  if (pkg?.main || pkg?.exports) {
+    interfaces.module = { main: pkg.main || pkg.exports };
+  }
+
+  // 3. MCP Server: mcp-server.mjs/js/ts or dist/mcp-server.js
+  const mcpFiles = ['mcp-server.mjs', 'mcp-server.js', 'mcp-server.ts', 'dist/mcp-server.js'];
+  for (const f of mcpFiles) {
+    if (existsSync(join(repoPath, f))) {
+      interfaces.mcp = { file: f, name: pkg?.name || basename(repoPath) };
+      break;
+    }
+  }
+
+  // 4. OpenClaw Plugin: openclaw.plugin.json exists
+  const ocPlugin = join(repoPath, 'openclaw.plugin.json');
+  if (existsSync(ocPlugin)) {
+    interfaces.openclaw = { config: readJSON(ocPlugin), path: ocPlugin };
+  }
+
+  // 5. Skill: SKILL.md exists
+  if (existsSync(join(repoPath, 'SKILL.md'))) {
+    interfaces.skill = { path: join(repoPath, 'SKILL.md') };
+  }
+
+  // 6. Claude Code Hook: guard.mjs or claudeCode.hook in package.json
+  if (pkg?.claudeCode?.hook) {
+    interfaces.claudeCodeHook = pkg.claudeCode.hook;
+  } else if (existsSync(join(repoPath, 'guard.mjs'))) {
+    interfaces.claudeCodeHook = {
+      event: 'PreToolUse',
+      matcher: 'Edit|Write',
+      command: `node "${join(repoPath, 'guard.mjs')}"`,
+      timeout: 5
+    };
+  }
+
+  return { interfaces, pkg };
+}
+
+/**
+ * Describe detected interfaces as a human-readable summary.
+ */
+export function describeInterfaces(interfaces) {
+  const lines = [];
+  const names = Object.keys(interfaces);
+
+  if (names.length === 0) {
+    return 'No interfaces detected.';
+  }
+
+  if (interfaces.cli) {
+    const bins = typeof interfaces.cli.bin === 'string' ? [interfaces.cli.name] : Object.keys(interfaces.cli.bin);
+    lines.push(`CLI: ${bins.join(', ')}`);
+  }
+  if (interfaces.module) lines.push(`Module: ${JSON.stringify(interfaces.module.main)}`);
+  if (interfaces.mcp) lines.push(`MCP Server: ${interfaces.mcp.file}`);
+  if (interfaces.openclaw) lines.push(`OpenClaw Plugin: ${interfaces.openclaw.config?.name || 'detected'}`);
+  if (interfaces.skill) lines.push(`Skill: SKILL.md`);
+  if (interfaces.claudeCodeHook) lines.push(`Claude Code Hook: ${interfaces.claudeCodeHook.event || 'PreToolUse'}`);
+
+  return `${names.length} interface(s): ${names.join(', ')}\n${lines.map(l => `  ${l}`).join('\n')}`;
+}
+
+/**
+ * Detect interfaces and return a structured JSON-serializable result.
+ */
+export function detectInterfacesJSON(repoPath) {
+  const { interfaces, pkg } = detectInterfaces(repoPath);
+  return {
+    repo: basename(repoPath),
+    package: pkg?.name || null,
+    version: pkg?.version || null,
+    interfaces: Object.fromEntries(
+      Object.entries(interfaces).map(([type, info]) => [type, {
+        detected: true,
+        ...info,
+      }])
+    ),
+    interfaceCount: Object.keys(interfaces).length,
+  };
+}

package/examples/minimal/README.md

@@ -0,0 +1,20 @@
+# Minimal Universal Interface Template
+
+The smallest possible agent-native tool. Four files, four interfaces.
+
+```
+core.mjs         ← your logic
+cli.mjs          ← thin CLI wrapper
+mcp-server.mjs   ← MCP server
+SKILL.md         ← agent instructions
+package.json     ← name, bin, exports
+```
+
+Copy this folder, rename everything, replace `hello()` with your functions.
+
+## Test it
+
+```bash
+node cli.mjs world       # Hello, world!
+wip-install --dry-run .  # Detected 4 interface(s): cli, module, mcp, skill
+```

package/examples/minimal/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: my-tool
+version: 1.0.0
+description: A minimal example tool.
+metadata:
+  category: example
+  capabilities:
+    - hello
+author:
+  name: Your Name
+---
+
+# my-tool
+
+A minimal example of the six-door pattern.
+
+## When to Use This Skill
+
+Use `hello` when you need to greet someone.
+
+## API Reference
+
+### hello(options)
+
+```javascript
+import { hello } from './core.mjs';
+hello({ name: 'world' }); // "Hello, world!"
+```

package/examples/minimal/cli.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { hello } from './core.mjs';
+const name = process.argv[2];
+console.log(hello({ name }));

package/examples/minimal/core.mjs

@@ -0,0 +1,8 @@
+/**
+ * Minimal six-door tool template.
+ * Replace this with your actual logic.
+ */
+
+export function hello({ name = 'world' } = {}) {
+  return `Hello, ${name}!`;
+}

package/examples/minimal/mcp-server.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { hello } from './core.mjs';
+
+const server = new Server(
+  { name: 'my-tool', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler({ method: 'tools/list' }, async () => ({
+  tools: [{
+    name: 'hello',
+    description: 'Say hello',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+    },
+  }],
+}));
+
+server.setRequestHandler({ method: 'tools/call' }, async (req) => ({
+  content: [{ type: 'text', text: hello(req.params.arguments) }],
+}));
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/examples/minimal/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "my-tool",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "core.mjs",
+  "bin": {
+    "my-tool": "./cli.mjs"
+  },
+  "exports": {
+    ".": "./core.mjs"
+  }
+}

package/install.mjs

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+// wip-universal-installer/install.mjs
+// Reference installer for agent-native software.
+// Reads a repo, detects available interfaces, installs them all.
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync } from 'node:fs';
+import { join, basename, resolve } from 'node:path';
+import { detectInterfaces, describeInterfaces, detectInterfacesJSON } from './detect.mjs';
+
+const OPENCLAW_DIR = join(process.env.HOME, '.openclaw');
+const EXTENSIONS_DIR = join(OPENCLAW_DIR, 'extensions');
+
+// Flags
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run');
+const JSON_OUTPUT = args.includes('--json');
+const target = args.find(a => !a.startsWith('--'));
+
+function log(msg) { if (!JSON_OUTPUT) console.log(`  ${msg}`); }
+function ok(msg) { if (!JSON_OUTPUT) console.log(`  ✓ ${msg}`); }
+function skip(msg) { if (!JSON_OUTPUT) console.log(`  - ${msg}`); }
+function fail(msg) { if (!JSON_OUTPUT) console.error(`  ✗ ${msg}`); }
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function installCLI(repoPath, door) {
+  if (DRY_RUN) {
+    ok(`CLI: would install globally (dry run)`);
+    return true;
+  }
+  try {
+    execSync('npm install -g .', { cwd: repoPath, stdio: 'pipe' });
+    const binNames = typeof door.bin === 'string' ? [basename(repoPath)] : Object.keys(door.bin);
+    ok(`CLI: ${binNames.join(', ')} installed globally`);
+    return true;
+  } catch (e) {
+    try {
+      execSync('npm link', { cwd: repoPath, stdio: 'pipe' });
+      ok(`CLI: linked globally via npm link`);
+      return true;
+    } catch {
+      fail(`CLI: install failed. Run manually: cd "${repoPath}" && npm install -g .`);
+      return false;
+    }
+  }
+}
+
+function installOpenClaw(repoPath, door) {
+  const name = door.config?.name || basename(repoPath);
+  const dest = join(EXTENSIONS_DIR, name);
+
+  if (DRY_RUN) {
+    ok(`OpenClaw: would copy to ${dest} (dry run)`);
+    return true;
+  }
+
+  if (existsSync(dest)) {
+    skip(`OpenClaw: ${name} already installed at ${dest}`);
+    return true;
+  }
+
+  try {
+    mkdirSync(dest, { recursive: true });
+    cpSync(repoPath, dest, { recursive: true, filter: (src) => !src.includes('.git') });
+    ok(`OpenClaw: copied to ${dest}`);
+
+    if (existsSync(join(dest, 'package.json'))) {
+      try {
+        execSync('npm install --omit=dev', { cwd: dest, stdio: 'pipe' });
+        ok(`OpenClaw: dependencies installed`);
+      } catch {
+        skip(`OpenClaw: no deps needed`);
+      }
+    }
+    return true;
+  } catch (e) {
+    fail(`OpenClaw: copy failed. ${e.message}`);
+    return false;
+  }
+}
+
+function installClaudeCodeHook(repoPath, door) {
+  const settingsPath = join(process.env.HOME, '.claude', 'settings.json');
+  let settings = readJSON(settingsPath);
+
+  if (!settings) {
+    skip(`Claude Code: no settings.json found at ${settingsPath}`);
+    return false;
+  }
+
+  if (DRY_RUN) {
+    ok(`Claude Code: would add ${door.event || 'PreToolUse'} hook (dry run)`);
+    return true;
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+  const event = door.event || 'PreToolUse';
+
+  if (!settings.hooks[event]) settings.hooks[event] = [];
+
+  const hookCommand = door.command || `node "${join(repoPath, 'guard.mjs')}"`;
+  const existing = settings.hooks[event].some(entry =>
+    entry.hooks?.some(h => h.command === hookCommand)
+  );
+
+  if (existing) {
+    skip(`Claude Code: ${event} hook already configured`);
+    return true;
+  }
+
+  settings.hooks[event].push({
+    matcher: door.matcher || undefined,
+    hooks: [{
+      type: 'command',
+      command: hookCommand,
+      timeout: door.timeout || 10
+    }]
+  });
+
+  try {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    ok(`Claude Code: ${event} hook added to settings.json`);
+    return true;
+  } catch (e) {
+    fail(`Claude Code: failed to update settings.json. ${e.message}`);
+    return false;
+  }
+}
+
+async function main() {
+  if (!target || target === '--help' || target === '-h') {
+    console.log('');
+    console.log('  wip-install ... the reference installer for agent-native software');
+    console.log('');
+    console.log('  Usage:');
+    console.log('    wip-install /path/to/repo');
+    console.log('    wip-install https://github.com/org/repo');
+    console.log('    wip-install org/repo');
+    console.log('');
+    console.log('  Flags:');
+    console.log('    --dry-run   Detect interfaces without installing anything');
+    console.log('    --json      Output detection results as JSON');
+    console.log('');
+    console.log('  Interfaces it detects:');
+    console.log('    CLI        ... package.json bin entry -> npm install -g');
+    console.log('    Module     ... ESM main/exports -> importable');
+    console.log('    MCP Server ... mcp-server.mjs -> config for .mcp.json');
+    console.log('    OpenClaw   ... openclaw.plugin.json -> copies to extensions/');
+    console.log('    Skill      ... SKILL.md -> agent instructions');
+    console.log('    CC Hook    ... guard.mjs or claudeCode.hook -> settings.json');
+    console.log('');
+    process.exit(0);
+  }
+
+  // Resolve target: GitHub URL, org/repo shorthand, or local path
+  let repoPath;
+
+  if (target.startsWith('http') || target.startsWith('git@') || target.match(/^[\w-]+\/[\w.-]+$/)) {
+    const url = target.match(/^[\w-]+\/[\w.-]+$/)
+      ? `https://github.com/${target}.git`
+      : target;
+    const repoName = basename(url).replace('.git', '');
+    repoPath = join('/tmp', `wip-install-${repoName}`);
+
+    log('');
+    log(`Cloning ${url}...`);
+    try {
+      if (existsSync(repoPath)) {
+        execSync(`rm -rf "${repoPath}"`);
+      }
+      execSync(`git clone "${url}" "${repoPath}"`, { stdio: 'pipe' });
+      ok(`Cloned to ${repoPath}`);
+    } catch (e) {
+      fail(`Clone failed: ${e.message}`);
+      process.exit(1);
+    }
+  } else {
+    repoPath = resolve(target);
+    if (!existsSync(repoPath)) {
+      fail(`Path not found: ${repoPath}`);
+      process.exit(1);
+    }
+  }
+
+  // JSON mode: detect and output
+  if (JSON_OUTPUT) {
+    const result = detectInterfacesJSON(repoPath);
+    console.log(JSON.stringify(result, null, 2));
+    if (DRY_RUN) process.exit(0);
+    // If not dry run, continue with install but suppress output
+  }
+
+  // Detect interfaces
+  const { interfaces, pkg } = detectInterfaces(repoPath);
+  const ifaceNames = Object.keys(interfaces);
+
+  if (ifaceNames.length === 0) {
+    skip('No installable interfaces detected.');
+    process.exit(0);
+  }
+
+  if (!JSON_OUTPUT) {
+    console.log('');
+    const repoName = basename(repoPath);
+    console.log(`  Installing: ${repoName}${DRY_RUN ? ' (dry run)' : ''}`);
+    console.log(`  ${'─'.repeat(40)}`);
+    log(`Detected ${ifaceNames.length} interface(s): ${ifaceNames.join(', ')}`);
+    console.log('');
+  }
+
+  if (DRY_RUN && !JSON_OUTPUT) {
+    // In dry run, show what would happen
+    console.log(describeInterfaces(interfaces));
+    console.log('');
+    console.log('  Dry run complete. No changes made.');
+    console.log('');
+    process.exit(0);
+  }
+
+  // Install each interface
+  let installed = 0;
+
+  if (interfaces.cli) {
+    installCLI(repoPath, interfaces.cli);
+    installed++;
+  }
+
+  if (interfaces.openclaw) {
+    installOpenClaw(repoPath, interfaces.openclaw);
+    installed++;
+  }
+
+  if (interfaces.claudeCodeHook) {
+    installClaudeCodeHook(repoPath, interfaces.claudeCodeHook);
+    installed++;
+  }
+
+  if (interfaces.mcp) {
+    if (!JSON_OUTPUT) {
+      console.log('');
+      log(`MCP Server detected: ${interfaces.mcp.file}`);
+      log(`Add to .mcp.json:`);
+      console.log(JSON.stringify({
+        [interfaces.mcp.name]: {
+          command: 'node',
+          args: [join(repoPath, interfaces.mcp.file)]
+        }
+      }, null, 2));
+    }
+    installed++;
+  }
+
+  if (interfaces.skill) {
+    ok(`Skill: SKILL.md available at ${interfaces.skill.path}`);
+    installed++;
+  }
+
+  if (interfaces.module) {
+    ok(`Module: import from "${interfaces.module.main}"`);
+    installed++;
+  }
+
+  if (!JSON_OUTPUT) {
+    console.log('');
+    console.log(`  Done. ${installed} interface(s) processed.`);
+    console.log('');
+  }
+}
+
+main().catch(e => {
+  fail(e.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@wipcomputer/universal-installer",
+  "version": "2.1.1",
+  "type": "module",
+  "description": "The reference installer for agent-native software. Detects interfaces (CLI, Module, MCP, OpenClaw, Skill, CC Hook) and installs them all.",
+  "main": "detect.mjs",
+  "bin": {
+    "wip-install": "./install.mjs"
+  },
+  "exports": {
+    ".": "./detect.mjs",
+    "./detect": "./detect.mjs",
+    "./install": "./install.mjs"
+  },
+  "scripts": {
+    "test": "node install.mjs --help"
+  },
+  "keywords": [
+    "installer",
+    "agent-native",
+    "sensor",
+    "actuator",
+    "universal-interface",
+    "claude-code",
+    "openclaw",
+    "mcp",
+    "cli"
+  ],
+  "author": "Parker Todd Brooks",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wipcomputer/wip-universal-installer.git"
+  },
+  "homepage": "https://github.com/wipcomputer/wip-universal-installer"
+}