@cokefenta/pi-switch 0.2.0

package/README.md

@@ -0,0 +1,341 @@
+<div align="center">
+
+# pi-switch
+
+[![Version](https://img.shields.io/badge/version-0.2.0-blue.svg)](https://github.com/user/pi-switch/releases)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://github.com/user/pi-switch/releases)
+[![Built with Rust](https://img.shields.io/badge/built%20with-Rust-orange.svg)](https://www.rust-lang.org/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**TUI + CLI dual-mode profile switcher for pi agent**
+
+Manage provider profiles, switch models.json, and run a local proxy with failover. Interactive TUI with full CRUD, Dracula theme, and bilingual support.
+
+[English](#) | [中文](README_ZH.md)
+
+</div>
+
+---
+
+## 📖 About
+
+pi-switch is a lightweight profile switcher for [pi coding agent](https://pi.dev). It manages `~/.pi/agent/models.json` provider profiles — add, edit, remove, and switch between them via CLI or an interactive terminal UI.
+
+Built with Rust (napi-rs) as a native Node.js addon. The interactive TUI is modeled after cc-switch.
+
+---
+
+## 📸 Screenshots
+
+<div align="center">
+  <h3>Profiles</h3>
+  <img src="assets/screenshots/profiles.png" alt="Profiles" width="70%"/>
+</div>
+
+<br/>
+
+<table>
+  <tr>
+    <th>Home</th>
+    <th>Settings</th>
+  </tr>
+  <tr>
+    <td><img src="assets/screenshots/home.png" alt="Home" width="100%"/></td>
+    <td><img src="assets/screenshots/settings.png" alt="Settings" width="100%"/></td>
+  </tr>
+</table>
+
+## 🚀 Quick Start
+
+**TUI Mode (Recommended)**
+```bash
+pi-switch tui
+```
+Use the full-screen interface to manage providers, browse presets, inspect proxy status, and configure settings.
+
+**Command-Line Mode**
+```bash
+pi-switch provider list              # List all provider profiles
+pi-switch provider add <name> [--preset <id>] [--api-key <key>]  # Add a profile
+pi-switch use <name>                 # Switch pi to this profile
+pi-switch provider show <name>       # Show profile details
+pi-switch provider delete <name>     # Delete a profile
+pi-switch presets list               # List built-in provider presets
+pi-switch config show                # Display current config
+pi-switch config backups             # List backup files
+pi-switch stats                      # View proxy request statistics
+pi-switch doctor                     # Run environment diagnostics
+```
+
+---
+
+## 📥 Installation
+
+### npm (Recommended)
+
+```bash
+npm install -g pi-switch
+```
+
+### Pi Package
+
+```bash
+pi install npm:pi-switch
+```
+
+### Build from Source
+
+**Prerequisites:**
+- Node.js >= 20
+- Rust 1.80+ ([install via rustup](https://rustup.rs/))
+
+**Build:**
+```bash
+git clone https://github.com/user/pi-switch.git
+cd pi-switch
+npm install
+npm run build:native
+node bin/pi-switch.js tui
+```
+
+---
+
+## ✨ Features
+
+### 🔌 Provider Management
+
+Manage provider configurations for pi agent. Built-in presets: OpenRouter, Anthropic, DeepSeek, SiliconFlow, OpenAI.
+
+**Features:** add, edit, delete, duplicate, current marker, proxy badge, provider ID display, search/filter.
+
+```bash
+pi-switch provider list              # List all provider profiles
+pi-switch provider show <name>       # Show profile details
+pi-switch provider add <name> [--preset <preset>]
+pi-switch provider delete <name>     # Delete profile
+pi-switch provider duplicate <name> [--as <new-name>]
+pi-switch use <name> [--mode merge|exclusive]  # Switch pi to profile
+```
+
+### 💡 Built-in Presets
+
+Ready-to-use provider templates with pre-configured API endpoints and models.
+
+```bash
+pi-switch presets list               # List all presets
+pi-switch presets show <id>          # Show preset detail
+```
+
+In the TUI: Presets → Enter to create a profile from a preset template.
+
+### ⚙️ Configuration Management
+
+Manage config backups, imports, and exports with encryption.
+
+```bash
+pi-switch config show                # Display full config
+pi-switch config path                # Show config file path
+pi-switch config backups             # List backup files
+pi-switch config export <passphrase> # Encrypted export (AES-256-CBC)
+pi-switch config import <path> <passphrase>  # Encrypted import
+```
+
+### 🌉 Local Proxy
+
+OpenAI-compatible proxy with Anthropic auto-conversion, failover chain, and circuit breaker.
+
+```bash
+pi-switch proxy start  [--host <ip>] [--port <port>] [--profile <name>]
+pi-switch proxy stop
+pi-switch proxy status
+```
+
+Endpoints:
+- `GET /health`
+- `GET /v1/models`
+- `POST /v1/chat/completions` (OpenAI → Anthropic auto-conversion)
+- `POST /v1/messages` (Anthropic native forwarding)
+
+### 📊 Usage Statistics
+
+Request metrics aggregated from proxy logs.
+
+```bash
+pi-switch stats
+```
+
+Displays: total requests, success rate, per-provider breakdown, per-model breakdown, average latency.
+
+### 🩺 Diagnostics
+
+```bash
+pi-switch doctor
+```
+
+Checks: config file existence, models.json validity, JSON structure, profile count, backup directory.
+
+### 🌐 Multi-language Support
+
+Interactive TUI supports English and Chinese. Language is persisted to config.
+
+- Default language: English (set `PI_SWITCH_LANG=zh` for initial Chinese)
+- In TUI: ⚙️ Settings → Language → `←→/Space` to switch
+
+### 🖥️ Interactive TUI
+
+```bash
+pi-switch tui
+```
+
+Full interactive terminal UI built with ratatui:
+
+- **Profiles**: table with proxy badge, provider ID, current marker, add/edit/delete/duplicate/switch/search
+- **Presets**: browse preset templates, create profile from preset
+- **Proxy**: start/stop daemon, view status with target/failover/listen info
+- **Stats**: request metrics by provider and model
+- **Backups**: browse config backup history
+- **Settings**: language (English / 中文), proxy host/port/target/failover editing
+
+Key bindings:
+- `←→` switch between menu and content
+- `↑↓ / j k` move selection
+- `Enter` open detail / confirm
+- `?` help overlay
+- `/` filter
+- `q` quit
+
+---
+
+## 🏗️ Architecture
+
+### Core Design
+
+- **napi-rs native addon**: Rust core compiled to `.node` binary for Node.js
+- **pi-switch config**: `~/.pi-switch/config.json` with profiles, proxy settings, backup metadata
+- **pi models.json**: `~/.pi/agent/models.json` — the file pi reads for provider definitions
+- **Atomic writes**: Temp file + rename pattern prevents corruption
+- **Backup rotation**: Auto-backup on every mutation, stored in `~/.pi-switch/backups/`
+
+### Config Files
+
+- `~/.pi-switch/config.json` — Profiles, current selection, proxy settings
+- `~/.pi-switch/backups/` — Timestamped config backups
+- `~/.pi/agent/models.json` — pi agent provider registry (written by `pi-switch use`)
+
+### Code Structure
+
+```
+pi-switch/
+├── bin/pi-switch.js         # CLI entry point
+├── index.js                 # NAPI re-exports
+├── pi-switch-native.cjs     # NAPI loader (auto platform detection)
+├── src-rust/
+│   ├── lib.rs               # NAPI function exports
+│   ├── config.rs            # Config load/save, types
+│   ├── ops.rs               # Core operations (use/upsert/remove/duplicate)
+│   ├── presets.rs           # Built-in provider presets
+│   ├── daemon.rs            # Proxy daemon management
+│   ├── stats.rs             # Request log aggregation
+│   └── tui/                 # Interactive terminal UI
+│       ├── app.rs           # State machine + key handler
+│       ├── form.rs          # Provider form state
+│       ├── text_edit.rs     # Readline-style text input
+│       ├── theme.rs         # Dracula theme + color fallback
+│       ├── route.rs         # Navigation routes
+│       ├── i18n.rs          # Bilingual text (English / 中文)
+│       └── ui/              # Rendering (chrome/pages/profiles/overlay)
+├── package.json
+└── Cargo.toml
+```
+
+---
+
+## ❓ FAQ
+
+<details>
+<summary><b>How do I switch pi to a different provider?</b></summary>
+
+<br>
+
+```bash
+pi-switch use <name>
+```
+
+This updates `~/.pi/agent/models.json` so pi picks up the new provider. If pi is already running, use `/model` inside pi to refresh.
+
+Alternatively: open the TUI, navigate to Profiles, and press `Space` on any profile.
+
+</details>
+
+<details>
+<summary><b>How do I add a custom provider?</b></summary>
+
+<br>
+
+**CLI:**
+```bash
+pi-switch provider add my-provider --api openai-completions --base-url https://api.example.com/v1 --api-key '$MY_API_KEY' --model gpt-4
+```
+
+**TUI:** Profiles → `a` → fill in form → `Ctrl+S`
+
+</details>
+
+<details>
+<summary><b>What does the [proxy] badge mean?</b></summary>
+
+<br>
+
+A profile with the `[proxy]` badge has `"proxy": true` in its config. This means it's configured to route through the local proxy. The proxy can auto-convert between OpenAI and Anthropic formats and apply failover/circuit-breaker policies.
+
+</details>
+
+<details>
+<summary><b>How do I set up failover?</b></summary>
+
+<br>
+
+In the TUI: ⚙️ Settings → Failover chain → `Enter` → enter comma-separated profile names → `Enter` to save.
+
+Or directly in `~/.pi-switch/config.json` under `settings.proxy.failover`.
+
+</details>
+
+<details>
+<summary><b>Where is my data stored?</b></summary>
+
+<br>
+
+All pi-switch data is under `~/.pi-switch/`. pi's own provider registry is `~/.pi/agent/models.json`. No data is sent anywhere.
+
+</details>
+
+---
+
+## 🛠️ Development
+
+### Requirements
+
+- **Node.js**: >= 20
+- **Rust**: 1.80+ ([rustup](https://rustup.rs/))
+- **npm**: bundled with Node.js
+
+### Commands
+
+```bash
+cd pi-switch
+
+npm run build:native:debug      # Build Rust native addon (debug)
+npm run build:native            # Build Rust native addon (release)
+node bin/pi-switch.js tui       # Run TUI
+
+cargo build                     # Rust-only build
+cargo clippy                    # Lint
+cargo fmt                       # Format
+```
+
+---
+
+## 📜 License
+
+MIT

package/bin/pi-switch.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+import {
+  initConfig, addProvider, listProfiles, showProfile, useProfile, removeProfile,
+  listPresets, showPreset, listBackups, doctor,
+  daemonStartNative, daemonStopNative, daemonStatusNative,
+  getUsageStats, exportConfig, importConfig,
+  runNativeTui,
+} from "../index.js";
+
+function usage() {
+  console.log(`pi-switch v0.2.0 — lightweight profile switcher for pi agent
+
+Usage:
+  pi-switch provider list
+  pi-switch provider show <name>
+  pi-switch provider add <name> [--preset <preset>] [--api <api>] [--base-url <url>] [--api-key <key>] [--model <id>...]
+  pi-switch provider edit <name>
+  pi-switch provider delete <name>
+  pi-switch provider duplicate <name> [--as <new-name>]
+  pi-switch use <name> [--mode merge|exclusive]
+  pi-switch presets [list]
+  pi-switch presets show <id>
+  pi-switch config show
+  pi-switch config path
+  pi-switch config export <passphrase>
+  pi-switch config import <path> <passphrase>
+  pi-switch config backups
+  pi-switch proxy start  [--host <ip>] [--port <port>] [--profile <name>]
+  pi-switch proxy stop
+  pi-switch proxy status
+  pi-switch stats
+  pi-switch doctor
+  pi-switch tui
+
+Aliases: remove → provider delete, rm → provider delete, interactive/ui → tui
+`);
+}
+
+function fail(message, code = 1) {
+  const clean = message.startsWith("Error: ") ? message : `Error: ${message}`;
+  console.error(clean);
+  process.exit(code);
+}
+
+function parseModel(modelArg) {
+  const idx = modelArg.indexOf("=");
+  const id = idx === -1 ? modelArg.trim() : modelArg.slice(0, idx).trim();
+  const name = idx === -1 ? undefined : modelArg.slice(idx + 1).trim();
+  if (!id) throw new Error(`invalid --model '${modelArg}'`);
+  return { id, ...(name ? { name } : {}), input: ["text"], contextWindow: 128000, maxTokens: 16384, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } };
+}
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) { out._.push(arg); continue; }
+    const eq = arg.indexOf("=");
+    const key = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
+    const raw = eq === -1 ? argv[++i] : arg.slice(eq + 1);
+    if (raw === undefined || raw.startsWith("--")) throw new Error(`missing value for --${key}`);
+    if (out[key] === undefined) out[key] = raw;
+    else if (Array.isArray(out[key])) out[key].push(raw);
+    else out[key] = [out[key], raw];
+  }
+  return out;
+}
+
+function asArray(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  try {
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") return usage();
+
+    // ─── Aliases ─────────────────────────────────────
+
+    const effectiveCmd = (() => {
+      if (cmd === "remove" || cmd === "rm") return "provider-delete";
+      if (cmd === "interactive" || cmd === "ui") return "tui";
+      return cmd;
+    })();
+
+    // ─── Init ────────────────────────────────────────
+
+    if (effectiveCmd === "init") {
+      for (const line of initConfig()) console.log(line);
+      return;
+    }
+
+    // ─── Provider subcommands ────────────────────────
+
+    if (effectiveCmd === "provider" || effectiveCmd === "provider-delete") {
+      const sub = effectiveCmd === "provider-delete" ? "delete" : (rest[0] || "list");
+
+      if (sub === "list") {
+        const data = JSON.parse(listProfiles());
+        const names = Object.keys(data.profiles);
+        if (names.length === 0) { console.log("No profiles. Add one with: pi-switch provider add <name> ..."); return; }
+        for (const name of names) {
+          const p = data.profiles[name];
+          const mark = data.current === name ? "*" : " ";
+          const models = (p.models || []).map(m => m.id).join(", ");
+          console.log(`${mark} ${name}`);
+          console.log(`    api: ${p.api}    baseUrl: ${p.baseUrl}`);
+          if (models) console.log(`    models: ${models}`);
+        }
+        return;
+      }
+
+      if (sub === "show" || sub === "info") {
+        const name = rest[1];
+        if (!name) fail("provider name required");
+        const result = JSON.parse(showProfile(name));
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      if (sub === "add") {
+        const args = parseArgs(rest.slice(1));
+        const name = args._[0];
+        if (!name) fail("provider name required");
+        const modelArgs = asArray(args.model);
+        const result = addProvider({
+          name,
+          preset: args.preset || undefined,
+          api: args.api || undefined,
+          baseUrl: args["base-url"] || args.baseUrl || undefined,
+          apiKey: args["api-key"] || args.apiKey || undefined,
+          models: modelArgs.length ? modelArgs.map(m => typeof m === 'string' ? parseModel(m).id : m) : undefined,
+        });
+        console.log(`Saved profile '${result.name}' to ~/.pi-switch/config.json`);
+        if (result.backup) console.log(`Backup: ${result.backup}`);
+        return;
+      }
+
+      if (sub === "edit") {
+        // provider edit opens TUI at the edit form for the given provider
+        const name = rest[1];
+        if (!name) fail("provider name required");
+        const data = JSON.parse(showProfile(name));
+        console.log(`Current config for '${name}':`);
+        console.log(JSON.stringify(data, null, 2));
+        console.log(`\nTo edit, use: pi-switch tui → Profiles → ${name} → e (edit)`);
+        return;
+      }
+
+      if (sub === "delete" || sub === "remove" || sub === "rm") {
+        const name = rest[1];
+        if (!name) fail("provider name required");
+        const result = removeProfile(name);
+        console.log(`Removed profile '${result.name}'`);
+        if (result.backup) console.log(`Backup: ${result.backup}`);
+        return;
+      }
+
+      if (sub === "duplicate" || sub === "copy") {
+        const name = rest[1];
+        if (!name) fail("provider name required");
+        const args = parseArgs(rest.slice(2));
+        const dst = args.as || args._[0] || `${name}-copy`;
+        // Reuse addProvider with the source's config
+        const data = JSON.parse(showProfile(name));
+        const p = data.profile;
+        const result = addProvider({
+          name: dst,
+          api: p.api,
+          baseUrl: p.baseUrl,
+          apiKey: p.apiKey,
+          models: (p.models || []).map(m => m.id),
+        });
+        console.log(`Duplicated '${name}' as '${dst}'`);
+        if (result.backup) console.log(`Backup: ${result.backup}`);
+        return;
+      }
+
+      fail(`unknown provider subcommand: '${sub}'`);
+    }
+
+    // ─── Use (shortcut) ──────────────────────────────
+
+    if (effectiveCmd === "use") {
+      const args = parseArgs(rest);
+      const name = args._[0];
+      if (!name) fail("profile name required");
+      const result = useProfile(name, args.mode || undefined);
+      console.log(`Activated '${result.name}' as provider '${result.providerId}'`);
+      if (result.modelsBackup) console.log(`Backup: ${result.modelsBackup}`);
+      console.log("Open /model in pi to refresh model list if pi is already running.");
+      return;
+    }
+
+    // ─── Presets ─────────────────────────────────────
+
+    if (effectiveCmd === "presets" || effectiveCmd === "preset") {
+      const sub = rest[0] || "list";
+      if (sub === "list") {
+        let first = true;
+        for (const p of listPresets()) {
+          if (!first) console.log("");
+          first = false;
+          console.log(`${p.id}  — ${p.description}`);
+          console.log(`    api: ${p.api}    baseUrl: ${p.baseUrl}`);
+          console.log(`    models: ${p.models.join(", ")}`);
+        }
+        return;
+      }
+      if (sub === "show") {
+        const id = rest[1];
+        if (!id) fail("preset id required");
+        console.log(showPreset(id));
+        return;
+      }
+      fail("usage: pi-switch presets [list|show <id>]");
+    }
+
+    // ─── Config subcommands ──────────────────────────
+
+    if (effectiveCmd === "config") {
+      const sub = rest[0] || "show";
+      if (sub === "show" || sub === "list") {
+        const data = JSON.parse(listProfiles());
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (sub === "path") {
+        console.log(JSON.parse(listProfiles())._configPath || "~/.pi-switch/config.json");
+        return;
+      }
+      if (sub === "export") {
+        const pw = rest[1];
+        if (!pw) fail("passphrase required");
+        console.log(exportConfig(pw));
+        return;
+      }
+      if (sub === "import") {
+        const filePath = rest[1];
+        const passphrase = rest[2];
+        if (!filePath || !passphrase) fail("usage: pi-switch config import <path> <passphrase>");
+        console.log(importConfig(filePath, passphrase));
+        return;
+      }
+      if (sub === "backups" || sub === "backup") {
+        const result = listBackups();
+        if (result.length === 0) console.log("No backups found.");
+        else for (const file of result) console.log(file);
+        return;
+      }
+      fail(`unknown config subcommand: '${sub}'`);
+    }
+
+    // ─── Proxy subcommands ───────────────────────────
+
+    if (effectiveCmd === "proxy") {
+      const sub = rest[0] || "status";
+
+      if (sub === "start") {
+        const args = {};
+        for (let i = 1; i < rest.length; i++) {
+          if (rest[i] === "--host") args.host = rest[++i];
+          else if (rest[i] === "--port") args.port = parseInt(rest[++i], 10);
+          else if (rest[i] === "--profile") args.profile = rest[++i];
+        }
+        const result = JSON.parse(daemonStartNative(args.host || null, args.port || null));
+        console.log(result.message);
+        if (result.pid) console.log(`PID: ${result.pid}`);
+        if (args.profile) {
+          const useResult = useProfile(args.profile);
+          console.log(`Using profile '${useResult.name}' as provider '${useResult.providerId}'`);
+        }
+        return;
+      }
+
+      if (sub === "stop") {
+        const result = JSON.parse(daemonStopNative());
+        console.log(result.message);
+        return;
+      }
+
+      if (sub === "status") {
+        const result = JSON.parse(daemonStatusNative());
+        if (result.running) {
+          console.log(`Proxy daemon is running (PID ${result.pid})`);
+          console.log(`Listen: http://${result.host}:${result.port}`);
+          if (result.target) console.log(`Target: ${result.target}`);
+          if (result.failover?.length) console.log(`Failover: ${result.failover.join(" → ")}`);
+        } else {
+          console.log(result.message);
+        }
+        return;
+      }
+
+      fail("usage: pi-switch proxy [start|stop|status]");
+    }
+
+    // ─── Stats ───────────────────────────────────────
+
+    if (effectiveCmd === "stats") {
+      const stats = JSON.parse(getUsageStats());
+      if (stats.totalRequests === 0) {
+        console.log("No request data. Start the proxy and make some requests first.");
+        return;
+      }
+      console.log(`Total: ${stats.totalRequests} | OK: ${stats.okRequests} | Fail: ${stats.failedRequests} | Rate: ${stats.successRate}`);
+      if (stats.avgLatencyMs) console.log(`Avg latency: ${stats.avgLatencyMs}ms`);
+      if (Object.keys(stats.byProvider).length) {
+        console.log("\nBy Provider:");
+        for (const [name, ps] of Object.entries(stats.byProvider)) {
+          const rate = ps.total > 0 ? ((ps.ok / ps.total) * 100).toFixed(0) + "%" : "0%";
+          console.log(`  ${name}: ${ps.total} req, ${ps.ok} ok (${rate})`);
+        }
+      }
+      return;
+    }
+
+    // ─── Doctor ──────────────────────────────────────
+
+    if (effectiveCmd === "doctor") {
+      const checks = doctor();
+      let failed = 0;
+      for (const c of checks) {
+        console.log(`${c.ok ? "✓" : "✗"} ${c.msg}`);
+        if (!c.ok) failed++;
+      }
+      if (failed) process.exit(1);
+      return;
+    }
+
+    // ─── TUI ─────────────────────────────────────────
+
+    if (effectiveCmd === "tui") {
+      runNativeTui();
+      return;
+    }
+
+    // ─── Legacy flat commands (backward compat) ──────
+
+    if (cmd === "list") {
+      const data = JSON.parse(listProfiles());
+      const names = Object.keys(data.profiles);
+      if (names.length === 0) { console.log("No profiles. Add one with: pi-switch provider add <name> ..."); return; }
+      for (const name of names) {
+        const p = data.profiles[name];
+        const mark = data.current === name ? "*" : " ";
+        const models = (p.models || []).map(m => m.id).join(", ");
+        console.log(`${mark} ${name}`);
+        console.log(`    api: ${p.api}    baseUrl: ${p.baseUrl}`);
+        if (models) console.log(`    models: ${models}`);
+      }
+      return;
+    }
+
+    if (cmd === "add") {
+      const args = parseArgs(rest);
+      const name = args._[0];
+      if (!name) fail("provider name required");
+      const modelArgs = asArray(args.model);
+      const result = addProvider({
+        name,
+        preset: args.preset || undefined,
+        api: args.api || undefined,
+        baseUrl: args["base-url"] || args.baseUrl || undefined,
+        apiKey: args["api-key"] || args.apiKey || undefined,
+        models: modelArgs.length ? modelArgs.map(m => typeof m === 'string' ? parseModel(m).id : m) : undefined,
+      });
+      console.log(`Saved profile '${result.name}' to ~/.pi-switch/config.json`);
+      if (result.backup) console.log(`Backup: ${result.backup}`);
+      return;
+    }
+
+    fail(`unknown command '${cmd}'. Run 'pi-switch help' for usage.`);
+  } catch (err) {
+    fail(err.stack || err.message);
+  }
+}
+
+main();

package/extensions/index.ts

@@ -0,0 +1,559 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { add as addProfile, doctor, installProxyProvider, list, preset, remove as removeProfile, setProxyTarget, update as updateProfile, use } from "../src/commands.js";
+import { loadConfig, profileToPiProvider, providerIdFor, saveConfig } from "../src/core.js";
+import { getCircuitState, resetCircuitState, daemonStart, daemonStop, daemonStatus } from "../src/proxy.js";
+import { getStats, formatStatsText } from "../src/stats.js";
+import { exportConfig, importConfig, getProfileInfo, openProvider } from "../src/sync.js";
+
+async function registerConfiguredProviders(pi: ExtensionAPI): Promise<string[]> {
+  const config = await loadConfig();
+  const registered: string[] = [];
+
+  for (const [name, profile] of Object.entries(config.profiles || {})) {
+    const providerId = providerIdFor(config, name);
+    pi.registerProvider(providerId, profileToPiProvider(profile as any) as any);
+    registered.push(providerId);
+  }
+
+  return registered;
+}
+
+function formatProfileList(result: Awaited<ReturnType<typeof list>>): string {
+  const names = Object.keys(result.profiles);
+  if (names.length === 0) return "No profiles. Add one with /piswitch add.";
+  return names
+    .map((name) => {
+      const p = result.profiles[name];
+      const mark = result.current === name ? "*" : " ";
+      const models = (p.models || []).map((m: any) => m.id).join(", ");
+      return `${mark} ${name}\n    api: ${p.api}\n    baseUrl: ${p.baseUrl}\n    models: ${models}`;
+    })
+    .join("\n");
+}
+
+async function showDoctor(ctx: ExtensionContext): Promise<void> {
+  const checks = await doctor();
+  const text = checks.map((c) => `${c.ok ? "✓" : "✗"} ${c.msg}`).join("\n");
+  ctx.ui.notify(text, checks.some((c) => !c.ok) ? "warning" : "info");
+}
+
+async function chooseProfile(ctx: ExtensionContext): Promise<string | null> {
+  const result = await list();
+  const names = Object.keys(result.profiles);
+  if (names.length === 0) {
+    ctx.ui.notify("No profiles. Add one with /piswitch add.", "warning");
+    return null;
+  }
+  const selected = await ctx.ui.select(
+    "pi-switch profiles",
+    names.map((name) => {
+      const p = result.profiles[name];
+      const mark = result.current === name ? "* " : "  ";
+      return `${mark}${name}  (${p.api})`;
+    }),
+  );
+  if (!selected) return null;
+  return selected.replace(/^\*?\s*/, "").split(/\s+/)[0] || null;
+}
+
+async function promptAddProvider(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const presetResult = await preset(["list"]);
+  const presetItems = presetResult.presets.map((p: any) => `${p.id} — ${p.description}`);
+  const selected = await ctx.ui.select("Choose provider preset", [
+    ...presetItems,
+    "custom-openai — Custom OpenAI-compatible endpoint",
+    "custom-anthropic — Custom Anthropic-compatible endpoint",
+  ]);
+  if (!selected) return;
+
+  const presetId = selected.split(" — ")[0];
+  const isCustomOpenAI = presetId === "custom-openai";
+  const isCustomAnthropic = presetId === "custom-anthropic";
+  const isCustom = isCustomOpenAI || isCustomAnthropic;
+
+  const defaultName = isCustom ? (isCustomOpenAI ? "custom-openai" : "custom-anthropic") : presetId;
+  const name = (await ctx.ui.input("Provider name", defaultName))?.trim();
+  if (!name) return;
+
+  let baseUrl: string | undefined;
+  let api: string | undefined;
+  let model: string | undefined;
+
+  if (isCustom) {
+    api = isCustomOpenAI ? "openai" : "anthropic";
+    const defaultUrl = isCustomOpenAI ? "https://api.example.com/v1" : "https://api.example.com";
+    baseUrl = (await ctx.ui.input("Base URL", defaultUrl))?.trim();
+    if (!baseUrl) return;
+    const defaultModel = isCustomOpenAI ? "model-id" : "claude-sonnet-4-5";
+    model = (await ctx.ui.input("Model id", defaultModel))?.trim();
+    if (!model) return;
+  }
+
+  const defaultKey = isCustom ? "$MY_API_KEY" : `$${presetId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+  const apiKey = (await ctx.ui.input("API key or env var", defaultKey))?.trim();
+  if (!apiKey) return;
+
+  const summary = isCustom
+    ? `Name: ${name}\nAPI: ${api}\nBase URL: ${baseUrl}\nAPI Key: ${apiKey}\nModel: ${model}`
+    : `Name: ${name}\nPreset: ${presetId}\nAPI Key: ${apiKey}`;
+  const ok = await ctx.ui.confirm("Create pi-switch provider?", summary);
+  if (!ok) return;
+
+  const argv = isCustom
+    ? [name, "--api", api!, "--base-url", baseUrl!, "--api-key", apiKey, "--model", model!]
+    : [name, "--preset", presetId, "--api-key", apiKey];
+
+  const result = await addProfile(argv);
+  const registered = await registerConfiguredProviders(pi);
+  const activate = await ctx.ui.confirm(
+    "Provider created",
+    `Created '${result.name}'.\nRegistered ${registered.length} provider(s).\n\nActivate it now?`,
+  );
+  if (activate) {
+    const activated = await use([result.name]);
+    await registerConfiguredProviders(pi);
+    ctx.ui.notify(`Activated '${activated.name}' as '${activated.providerId}'. Open /model to select it.`, "info");
+  } else {
+    ctx.ui.notify(`Created '${result.name}'. Use /piswitch use ${result.name} when ready.`, "info");
+  }
+}
+
+async function promptEditProvider(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const name = await chooseProfile(ctx);
+  if (!name) return;
+  const result = await list();
+  const profile = result.profiles[name];
+  if (!profile) return;
+
+  const action = await ctx.ui.select(`Edit ${name}`, [
+    "Edit API key",
+    "Edit Base URL",
+    "Edit models",
+    "Delete profile",
+  ]);
+  if (!action) return;
+
+  if (action === "Edit API key") {
+    const apiKey = (await ctx.ui.input("API key or env var", profile.apiKey || "$API_KEY"))?.trim();
+    if (!apiKey) return;
+    await updateProfile(name, { apiKey });
+    await registerConfiguredProviders(pi);
+    ctx.ui.notify(`Updated API key for '${name}'.`, "info");
+    return;
+  }
+
+  if (action === "Edit Base URL") {
+    const baseUrl = (await ctx.ui.input("Base URL", profile.baseUrl || "https://api.example.com/v1"))?.trim();
+    if (!baseUrl) return;
+    await updateProfile(name, { baseUrl });
+    await registerConfiguredProviders(pi);
+    ctx.ui.notify(`Updated Base URL for '${name}'.`, "info");
+    return;
+  }
+
+  if (action === "Edit models") {
+    const current = (profile.models || []).map((m: any) => (m.name ? `${m.id}=${m.name}` : m.id)).join(", ");
+    const text = (await ctx.ui.input("Models, comma separated. Use id or id=name", current))?.trim();
+    if (!text) return;
+    const models = text.split(",").map((s) => s.trim()).filter(Boolean).map((item) => {
+      const idx = item.indexOf("=");
+      const id = idx === -1 ? item : item.slice(0, idx).trim();
+      const modelName = idx === -1 ? undefined : item.slice(idx + 1).trim();
+      return {
+        id,
+        ...(modelName ? { name: modelName } : {}),
+        input: ["text"],
+        contextWindow: 128000,
+        maxTokens: 16384,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      };
+    });
+    await updateProfile(name, { models });
+    await registerConfiguredProviders(pi);
+    ctx.ui.notify(`Updated models for '${name}'.`, "info");
+    return;
+  }
+
+  if (action === "Delete profile") {
+    const ok = await ctx.ui.confirm("Delete provider?", `Delete '${name}' from pi-switch config?`);
+    if (!ok) return;
+    await removeProfile(name);
+    await registerConfiguredProviders(pi);
+    ctx.ui.notify(`Deleted '${name}'.`, "info");
+  }
+}
+
+async function promptShowProvider(ctx: ExtensionContext): Promise<void> {
+  const name = await chooseProfile(ctx);
+  if (!name) return;
+  const result = await list();
+  const profile = result.profiles[name];
+  if (!profile) return;
+  const models = (profile.models || []).map((m: any) => `- ${m.id}${m.name ? ` (${m.name})` : ""}`).join("\n");
+  ctx.ui.notify(
+    `Name: ${name}\nAPI: ${profile.api}\nBase URL: ${profile.baseUrl}\nAPI Key: ${profile.apiKey}\nPreset: ${profile.preset || "custom"}\nModels:\n${models || "- none"}`,
+    "info",
+  );
+}
+
+async function promptRemoveProvider(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const name = await chooseProfile(ctx);
+  if (!name) return;
+  const ok = await ctx.ui.confirm("Delete provider?", `Delete '${name}' from pi-switch config?`);
+  if (!ok) return;
+  await removeProfile(name);
+  await registerConfiguredProviders(pi);
+  ctx.ui.notify(`Deleted '${name}'.`, "info");
+}
+
+async function promptRawConfig(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const config = await loadConfig();
+  const edited = await ctx.ui.editor("Edit ~/.pi-switch/config.json", JSON.stringify(config, null, 2));
+  if (edited === undefined) return;
+  let parsed: any;
+  try {
+    parsed = JSON.parse(edited);
+  } catch (err: any) {
+    ctx.ui.notify(`Invalid JSON: ${err.message}`, "error");
+    return;
+  }
+  const ok = await ctx.ui.confirm("Save raw config?", "This will overwrite ~/.pi-switch/config.json.");
+  if (!ok) return;
+  await saveConfig(parsed);
+  const registered = await registerConfiguredProviders(pi);
+  ctx.ui.notify(`Saved raw config. Registered ${registered.length} provider(s).`, "info");
+}
+
+async function promptInstallProxy(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const action = await ctx.ui.select("Proxy", ["Install proxy provider", "Set target profile", "Circuit status", "Reset circuit", "Daemon start", "Daemon stop", "Daemon status"]);
+  if (!action) return;
+
+  if (action === "Daemon start") {
+    try {
+      const result = await daemonStart({});
+      ctx.ui.notify(result.message + (result.pid ? `\nPID: ${result.pid}\nLog: ${result.logPath}` : ""), "info");
+    } catch (err: any) {
+      ctx.ui.notify(`Daemon start failed: ${err.message}`, "error");
+    }
+    return;
+  }
+
+  if (action === "Daemon stop") {
+    const result = await daemonStop();
+    ctx.ui.notify(result.message, "info");
+    return;
+  }
+
+  if (action === "Daemon status") {
+    const result = await daemonStatus();
+    if (result.running) {
+      ctx.ui.notify(`Proxy daemon running\nPID: ${result.pid}\nListen: http://${result.host}:${result.port}\nTarget: ${result.target || "none"}\nFailover: ${result.failover?.join(" -> ") || "none"}`, "info");
+    } else {
+      ctx.ui.notify(result.message, "warning");
+    }
+    return;
+  }
+
+  if (action === "Set target profile") {
+    const target = await chooseNonProxyProfile(ctx);
+    if (!target) return;
+    const result = await list();
+    const others = Object.keys(result.profiles).filter((name) => name !== target && !result.profiles[name]?.proxy);
+    const failoverText = others.length
+      ? await ctx.ui.input("Failover profiles, comma separated (optional)", others.join(","))
+      : undefined;
+    const failover = failoverText?.split(",").map((s) => s.trim()).filter(Boolean);
+    const saved = await setProxyTarget(target, failover);
+    ctx.ui.notify(
+      `Proxy target set to '${saved.target}'.${saved.failover.length ? `\nFailover: ${saved.failover.join(" -> ")}` : ""}`,
+      "info",
+    );
+    return;
+  }
+
+  if (action === "Circuit status") {
+    ctx.ui.notify(JSON.stringify(await getCircuitState(), null, 2), "info");
+    return;
+  }
+
+  if (action === "Reset circuit") {
+    await resetCircuitState();
+    ctx.ui.notify("Circuit breaker state reset.", "info");
+    return;
+  }
+
+  const name = (await ctx.ui.input("Proxy provider name", "proxy"))?.trim();
+  if (!name) return;
+  const host = (await ctx.ui.input("Proxy host", "127.0.0.1"))?.trim();
+  if (!host) return;
+  const port = (await ctx.ui.input("Proxy port", "43112"))?.trim();
+  if (!port) return;
+  const result = await installProxyProvider([name, "--host", host, "--port", port]);
+  await registerConfiguredProviders(pi);
+  const activate = await ctx.ui.confirm(
+    "Proxy provider installed",
+    `Installed '${result.name}' -> http://${host}:${port}/v1.\n\nActivate it now?`,
+  );
+  if (activate) {
+    const activated = await use([result.name]);
+    ctx.ui.notify(`Activated '${activated.name}'. Start the proxy with: pi-switch proxy start`, "info");
+  } else {
+    ctx.ui.notify(`Installed '${result.name}'. Start proxy with: pi-switch proxy start`, "info");
+  }
+}
+
+async function chooseNonProxyProfile(ctx: ExtensionContext): Promise<string | null> {
+  const result = await list();
+  const names = Object.keys(result.profiles).filter((name) => !result.profiles[name]?.proxy);
+  if (names.length === 0) {
+    ctx.ui.notify("No non-proxy profiles. Add an upstream provider first with /piswitch add.", "warning");
+    return null;
+  }
+  const selected = await ctx.ui.select(
+    "Proxy target profile",
+    names.map((name) => `${name}  (${result.profiles[name].api})`),
+  );
+  return selected ? selected.split(/\s+/)[0] || null : null;
+}
+
+export default async function piSwitchExtension(pi: ExtensionAPI) {
+  try {
+    await registerConfiguredProviders(pi);
+  } catch {
+    // Avoid breaking pi startup if pi-switch has not been initialized yet.
+  }
+
+  pi.registerCommand("piswitch", {
+    description: "Manage pi-switch profiles",
+    getArgumentCompletions: (prefix) => {
+      const commands = ["add", "edit", "show", "remove", "raw", "proxy", "list", "use", "doctor", "reload", "presets", "stats", "info", "open", "export", "import", "menu"];
+      const matches = commands.filter((c) => c.startsWith(prefix.trim()));
+      return matches.length ? matches.map((value) => ({ value, label: value })) : null;
+    },
+    handler: async (args, ctx) => {
+      const [subcommand, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      const cmd = subcommand || "menu";
+
+      if (cmd === "add") {
+        await promptAddProvider(pi, ctx);
+        return;
+      }
+
+      if (cmd === "edit") {
+        await promptEditProvider(pi, ctx);
+        return;
+      }
+
+      if (cmd === "show") {
+        await promptShowProvider(ctx);
+        return;
+      }
+
+      if (cmd === "remove" || cmd === "rm") {
+        await promptRemoveProvider(pi, ctx);
+        return;
+      }
+
+      if (cmd === "raw") {
+        await promptRawConfig(pi, ctx);
+        return;
+      }
+
+      if (cmd === "proxy") {
+        await promptInstallProxy(pi, ctx);
+        return;
+      }
+
+      if (cmd === "list") {
+        ctx.ui.notify(formatProfileList(await list()), "info");
+        return;
+      }
+
+      if (cmd === "doctor") {
+        await showDoctor(ctx);
+        return;
+      }
+
+      if (cmd === "presets" || cmd === "preset") {
+        const result = await preset(["list"]);
+        ctx.ui.notify(
+          result.presets.map((p: any) => `${p.id}: ${p.description}\n  ${p.baseUrl}`).join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (cmd === "reload") {
+        const registered = await registerConfiguredProviders(pi);
+        ctx.ui.notify(`Registered ${registered.length} provider(s): ${registered.join(", ") || "none"}`, "info");
+        return;
+      }
+
+      if (cmd === "stats") {
+        const format = rest[0] || "summary";
+        const valid = ["summary", "by-provider", "by-model", "hourly", "full"];
+        if (!valid.includes(format)) {
+          ctx.ui.notify(`Invalid format '${format}'. Use: ${valid.join("|")}`, "warning");
+          return;
+        }
+        const stats = await getStats();
+        ctx.ui.notify(formatStatsText(stats, format), "info");
+        return;
+      }
+
+      if (cmd === "info") {
+        const name = rest[0] || (await chooseProfile(ctx));
+        if (!name) return;
+        try {
+          const result = await getProfileInfo(name);
+          const links = [];
+          if (result.links.manageKeys) links.push(`Manage keys: ${result.links.manageKeys}`);
+          links.push(`API docs: ${result.links.docs}`);
+          ctx.ui.notify(
+            `Name: ${result.name}\nAPI: ${result.api}\nBase URL: ${result.baseUrl}\nModels: ${result.models.join(", ")}\n\n${links.join("\n")}`,
+            "info",
+          );
+        } catch (err: any) {
+          ctx.ui.notify(err.message, "error");
+        }
+        return;
+      }
+
+      if (cmd === "open") {
+        const target = rest[0] || (await chooseProfile(ctx));
+        if (!target) return;
+        const result = await openProvider(target);
+        if (result?.opened) {
+          ctx.ui.notify(`Opened ${result.label}`, "info");
+        } else if (result?.url) {
+          ctx.ui.notify(`${result.label}: ${result.url}`, "info");
+        } else {
+          ctx.ui.notify(`No link for '${target}'`, "warning");
+        }
+        return;
+      }
+
+      if (cmd === "export") {
+        const passphrase = await ctx.ui.input("Passphrase (min 8 chars)", "");
+        if (!passphrase) return;
+        try {
+          const result = await exportConfig(passphrase.trim());
+          ctx.ui.notify(result.message, "info");
+        } catch (err: any) {
+          ctx.ui.notify(`Export failed: ${err.message}`, "error");
+        }
+        return;
+      }
+
+      if (cmd === "import") {
+        const filePath = await ctx.ui.input("Export file path", "");
+        if (!filePath) return;
+        const passphrase = await ctx.ui.input("Passphrase", "");
+        if (!passphrase) return;
+        try {
+          const result = await importConfig(filePath.trim(), passphrase.trim());
+          ctx.ui.notify(result.message + (result.sanitizedKeys ? `\n${result.sanitizedKeys} key(s) sanitized → env vars` : ""), "info");
+          await registerConfiguredProviders(pi);
+        } catch (err: any) {
+          ctx.ui.notify(`Import failed: ${err.message}`, "error");
+        }
+        return;
+      }
+
+      if (cmd === "use") {
+        const name = rest[0] || (await chooseProfile(ctx));
+        if (!name) return;
+        const result = await use([name]);
+        await registerConfiguredProviders(pi);
+        ctx.ui.notify(
+          `Activated '${result.name}' as '${result.providerId}'. Open /model to refresh/select the model.`,
+          "info",
+        );
+        return;
+      }
+
+      if (cmd !== "menu") {
+        ctx.ui.notify("Usage: /piswitch [add|edit|show|remove|raw|list|use|doctor|presets|reload|menu]", "warning");
+        return;
+      }
+
+      const selected = await ctx.ui.select("pi-switch", [
+        "Add provider",
+        "Edit provider",
+        "Show provider",
+        "Remove provider",
+        "Raw config editor",
+        "Install proxy provider",
+        "Use profile",
+        "List profiles",
+        "Preset list",
+        "Doctor",
+        "Reload registered providers",
+        "Usage stats",
+        "Open dashboard",
+        "Export config",
+        "Import config",
+      ]);
+      if (selected === "Add provider") {
+        await promptAddProvider(pi, ctx);
+      } else if (selected === "Edit provider") {
+        await promptEditProvider(pi, ctx);
+      } else if (selected === "Show provider") {
+        await promptShowProvider(ctx);
+      } else if (selected === "Remove provider") {
+        await promptRemoveProvider(pi, ctx);
+      } else if (selected === "Raw config editor") {
+        await promptRawConfig(pi, ctx);
+      } else if (selected === "Install proxy provider") {
+        await promptInstallProxy(pi, ctx);
+      } else if (selected === "Use profile") {
+        const name = await chooseProfile(ctx);
+        if (!name) return;
+        const result = await use([name]);
+        await registerConfiguredProviders(pi);
+        ctx.ui.notify(`Activated '${result.name}' as '${result.providerId}'. Open /model to refresh/select it.`, "info");
+      } else if (selected === "List profiles") {
+        ctx.ui.notify(formatProfileList(await list()), "info");
+      } else if (selected === "Preset list") {
+        const result = await preset(["list"]);
+        ctx.ui.notify(result.presets.map((p: any) => `${p.id}: ${p.description}\n  ${p.baseUrl}`).join("\n"), "info");
+      } else if (selected === "Doctor") {
+        await showDoctor(ctx);
+      } else if (selected === "Reload registered providers") {
+        const registered = await registerConfiguredProviders(pi);
+        ctx.ui.notify(`Registered ${registered.length} provider(s): ${registered.join(", ") || "none"}`, "info");
+      } else if (selected === "Usage stats") {
+        const stats = await getStats();
+        ctx.ui.notify(formatStatsText(stats, "summary"), "info");
+      } else if (selected === "Open dashboard") {
+        const name = await chooseProfile(ctx);
+        if (!name) return;
+        const result = await openProvider(name);
+        if (result?.opened) ctx.ui.notify(`Opened ${result.label}`, "info");
+        else if (result?.url) ctx.ui.notify(`${result.label}: ${result.url}`, "info");
+        else ctx.ui.notify(`No link for '${name}'`, "warning");
+      } else if (selected === "Export config") {
+        const passphrase = await ctx.ui.input("Passphrase (min 8 chars)", "");
+        if (!passphrase) return;
+        try {
+          const result = await exportConfig(passphrase.trim());
+          ctx.ui.notify(result.message, "info");
+        } catch (err: any) {
+          ctx.ui.notify(`Export failed: ${err.message}`, "error");
+        }
+      } else if (selected === "Import config") {
+        const filePath = await ctx.ui.input("Export file path", "");
+        if (!filePath) return;
+        const passphrase = await ctx.ui.input("Passphrase", "");
+        if (!passphrase) return;
+        try {
+          const result = await importConfig(filePath.trim(), passphrase.trim());
+          ctx.ui.notify(result.message + (result.sanitizedKeys ? `\n${result.sanitizedKeys} key(s) sanitized` : ""), "info");
+          await registerConfiguredProviders(pi);
+        } catch (err: any) {
+          ctx.ui.notify(`Import failed: ${err.message}`, "error");
+        }
+      }
+    },
+  });
+}

package/index.js

@@ -0,0 +1,28 @@
+// ESM wrapper for pi-switch native addon
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const native = require('./pi-switch-native.cjs');
+
+// Re-export all native functions
+export const {
+  initConfig,
+  listPresets,
+  showPreset,
+  addProvider,
+  listProfiles,
+  showProfile,
+  useProfile,
+  removeProfile,
+  listBackups,
+  doctor,
+  daemonStartNative,
+  daemonStopNative,
+  daemonStatusNative,
+  getUsageStats,
+  exportConfig,
+  importConfig,
+  exportDir,
+  runNativeTui,
+} = native;
+
+export default native;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@cokefenta/pi-switch",
+  "version": "0.2.0",
+  "description": "Lightweight profile switcher for pi models.json",
+  "type": "module",
+  "bin": {
+    "pi-switch": "./bin/pi-switch.js"
+  },
+  "main": "./index.js",
+  "napi": {
+    "name": "pi-switch-native",
+    "targets": [
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  "files": [
+    "bin",
+    "index.js",
+    "index.d.ts",
+    "pi-switch-native.cjs",
+    "pi-switch-native.darwin-arm64.node",
+    "pi-switch-native.darwin-x64.node",
+    "pi-switch-native.linux-x64-gnu.node",
+    "pi-switch-native.win32-x64-msvc.node",
+    "extensions"
+  ],
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build:native": "napi build --platform --release",
+    "build:native:debug": "napi build --platform",
+    "doctor": "node ./bin/pi-switch.js doctor",
+    "test": "node --test"
+  },
+  "keywords": [
+    "pi",
+    "pi-package",
+    "models",
+    "switch"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.7.1"
+  }
+}

package/pi-switch-native.cjs

@@ -0,0 +1,22 @@
+// Auto-generated loader for pi-switch-native
+const { existsSync } = require('fs');
+const { join, resolve } = require('path');
+
+const { platform, arch } = process;
+
+function getBinaryName() {
+  const parts = [platform];
+  parts.push(arch);
+  if (platform === 'linux') parts.push('gnu');
+  else if (platform === 'win32') parts.push('msvc');
+  return `pi-switch-native.${parts.join('-')}.node`;
+}
+
+const binaryName = getBinaryName();
+const localPath = resolve(__dirname, binaryName);
+
+if (!existsSync(localPath)) {
+  throw new Error(`Native binding not found: ${localPath}. Run: npm run build:native`);
+}
+
+module.exports = require(localPath);