Release v0.1.5: merge develop → main

Highlights since v0.1.4: Claude Code provider (clc/ prefix), Integrations app
(connect CLI coding tools), MITM (route Antigravity/Copilot through the gateway),
per-provider sticky/round-robin account rotation, account de-dup + email backfill,
plugins gated to Premium, skill list/remove/update, Gmail store client, plus terminal-profile and OTP/file-manager fixes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0122jfYFrAhahVut2aT2PtJi

Author: 2 people

cmd/enowx/cli.go

@@ -44,6 +44,11 @@ func httpJSON(method, url string) (map[string]any, int, error) {
 		Error string         `json:"error"`
 	}
 	_ = json.Unmarshal(b, &env)
+	// Surface the server's error message (e.g. the update's "reinstall to
+	// ~/.local/bin" guidance) as a real error so callers can print it verbatim.
+	if resp.StatusCode >= 300 && env.Error != "" {
+		return env.Data, resp.StatusCode, fmt.Errorf("%s", env.Error)
+	}
 	if env.Data == nil {
 		// Some endpoints (e.g. /health) aren't enveloped.
 		var raw map[string]any
@@ -210,10 +215,14 @@ func updateCmd(args []string) {
 		return
 	}
 	fmt.Println("downloading + installing…")
-	if _, code, err := httpJSON(http.MethodPost, base(cfg)+"/api/update"); err != nil || code >= 300 {
+	data, code, err := httpJSON(http.MethodPost, base(cfg)+"/api/update")
+	if err != nil || code >= 300 {
 		fmt.Fprintf(os.Stderr, "update failed (%d): %v\n", code, err)
 		os.Exit(1)
 	}
+	if note, _ := data["note"].(string); note != "" {
+		fmt.Println("\n" + note)
+	}
 	fmt.Println("update applied — enx will restart itself")
 }
 
@@ -285,6 +294,9 @@ Usage:
   enx tunnel stop       tear the tunnel down
   enx tunnel status     show the current tunnel URL
   enx skill install <slug> [-g]  install a skill (-g = global, else project)
+  enx skill list                list installed skills
+  enx skill remove <slug>       uninstall a skill
+  enx skill update <slug>       reinstall a skill to the latest version
   enx version           print the version
 `)
 }

cmd/enowx/main.go

@@ -10,23 +10,27 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 	"os/signal"
 	"runtime/debug"
 	"syscall"
 	"time"
 
 	"github.com/enowdev/enowx/config"
 	"github.com/enowdev/enowx/core/daemon"
+	"github.com/enowdev/enowx/core/mitm"
 	"github.com/enowdev/enowx/core/plugins"
 	"github.com/enowdev/enowx/core/pool"
 	"github.com/enowdev/enowx/core/provider"
 	"github.com/enowdev/enowx/core/provider/antigravity"
 	"github.com/enowdev/enowx/core/provider/codebuddy"
 	"github.com/enowdev/enowx/core/provider/commandcode"
 	"github.com/enowdev/enowx/core/provider/custommgr"
+	"github.com/enowdev/enowx/core/provider/claudecode"
 	"github.com/enowdev/enowx/core/provider/codex"
 	leonardoprovider "github.com/enowdev/enowx/core/provider/leonardo"
 	sunoprovider "github.com/enowdev/enowx/core/provider/suno"
@@ -43,6 +47,14 @@ import (
 var version = "dev"
 
 func main() {
+	// Hidden subcommand: the elevated MITM proxy child. Spawned (with an admin
+	// prompt) by the main process so only this small child runs as root — it binds
+	// :443, installs the CA + hosts entries, and serves the intercept proxy.
+	if len(os.Args) > 1 && os.Args[1] == "__mitm-serve" {
+		mitm.RunElevatedServe(os.Args[2:])
+		return
+	}
+
 	// The detached daemon child (ENOWX_DAEMON=1) always runs the server.
 	if daemon.IsDaemon() {
 		runServer()
@@ -112,15 +124,46 @@ func runServer() {
 	reg.Register(commandcode.New(doer))
 	reg.Register(kiro.New(doer, saveCreds))
 	reg.Register(codex.New(doer, saveCreds))
+	reg.Register(claudecode.New(doer, saveCreds))
 	reg.Register(antigravity.New(doer, saveCreds))
 	reg.Register(sunoprovider.New(doer))
 	reg.Register(leonardoprovider.New(doer))
 
-	px := proxy.New(reg, pool.New(db.Accounts()), doer)
+	px := proxy.New(reg, pool.New(db.Accounts()).WithSettings(db.Settings()), doer)
 	tun := tunnel.New(cfg.RuntimeDir, cfg.Port)
 	pluginMgr := plugins.New(cfg.PluginsDir(), cfg.Port)
 	syncMgr := syncpkg.New(db.Settings(), db.Music(), db.Logs())
 
+	// MITM: intercept a proprietary IDE's hardcoded endpoint and reroute it to us.
+	// The gateway URL is our own loopback; the API key is resolved lazily from the
+	// key store (first enabled key).
+	mitmMgr := mitm.New(
+		filepath.Join(cfg.RuntimeDir, "mitm"),
+		fmt.Sprintf("http://127.0.0.1:%d", cfg.Port),
+		func() string {
+			rows, err := db.Keys().List(context.Background())
+			if err == nil {
+				for _, k := range rows {
+					if k.Enabled && k.Secret != "" {
+						return k.Secret
+					}
+				}
+			}
+			return ""
+		},
+	)
+
+	// Plugins are premium-only: a plugin can only run/serve when the signed-in
+	// user has the entitlement (checked before the sidecar spawns and before the
+	// UI is served), so sharing a plugin and installing it manually doesn't bypass
+	// the paywall.
+	pluginMgr.SetGate(func() error {
+		if syncMgr.HasEntitlement(context.Background(), "plugins.use") {
+			return nil
+		}
+		return errors.New("plugins are a Premium feature — upgrade to use them")
+	})
+
 	// User-defined (custom) providers: register the stored ones live, then keep
 	// the registry/prefix/catalog in sync on change.
 	customMgr := custommgr.New(reg, db.CustomProviders(), custommgr.Catalog{
@@ -133,7 +176,7 @@ func runServer() {
 
 	// Full cloud sync: let the sync manager snapshot/apply accounts, gateway
 	// keys, aliases, and custom providers (custom providers register live).
-	syncMgr.SetFullSync(db.Accounts(), db.Keys(), db.Aliases(), db.CustomProviders(), db.Proxies(),
+	syncMgr.SetFullSync(db.Accounts(), db.Keys(), db.Aliases(), db.Combos(), db.CustomProviders(), db.Proxies(),
 		customMgr.RegisterOne, customMgr.UnregisterOne)
 	// Maintain the live channel (pull side) and the automatic push side. Both
 	// are no-ops until logged in; auto-push also obeys the global toggle.
@@ -151,9 +194,11 @@ func runServer() {
 		Music:      db.Music(),
 		SettingsKV: db.Settings(),
 		Aliases:    db.Aliases(),
+		Combos:     db.Combos(),
 		ApiTest:    db.ApiTest(),
 		Tunnel:     tun,
 		Plugins:    pluginMgr,
+		MITM:       mitmMgr,
 		Sync:       syncMgr,
 		CustomProv: customMgr,
 		Filters:    db.Filters(),

cmd/enowx/skill.go

@@ -10,10 +10,13 @@ import (
 
 const skillRepo = "https://github.com/enowdev/enowX-Skill.git"
 
-// skillCmd handles `enx skill install <slug> [-g]`.
+// skillCmd handles `enx skill install|list|remove|update <slug> [-g]`.
 //
 //	enx skill install <slug>       install into ./.agents/skill/<slug> (project)
 //	enx skill install <slug> -g    install into ~/.agents/skill/<slug> (global)
+//	enx skill list                 list installed skills
+//	enx skill remove <slug>        uninstall a skill
+//	enx skill update <slug>        reinstall to the latest version
 func skillCmd(args []string) {
 	sub := ""
 	if len(args) > 0 {
@@ -23,8 +26,17 @@ func skillCmd(args []string) {
 	switch sub {
 	case "install", "add":
 		skillInstall(args)
+	case "list":
+		skillList()
+	case "remove", "rm", "uninstall":
+		skillRemove(args)
+	case "update", "upgrade":
+		skillUpdate(args)
 	default:
 		fmt.Fprintln(os.Stderr, "usage: enx skill install <slug> [-g]")
+		fmt.Fprintln(os.Stderr, "       enx skill list")
+		fmt.Fprintln(os.Stderr, "       enx skill remove <slug>")
+		fmt.Fprintln(os.Stderr, "       enx skill update <slug>")
 		os.Exit(1)
 	}
 }
@@ -48,6 +60,10 @@ func skillInstall(args []string) {
 		fmt.Fprintln(os.Stderr, "usage: enx skill install <slug> [-g]")
 		os.Exit(1)
 	}
+	if !validSkillSlug(slug) {
+		fmt.Fprintf(os.Stderr, "invalid skill name %q\n", slug)
+		os.Exit(1)
+	}
 
 	// git is required for the sparse checkout.
 	if _, err := exec.LookPath("git"); err != nil {
@@ -56,15 +72,9 @@ func skillInstall(args []string) {
 	}
 
 	// Destination: ~/.agents/skill/<slug> (global) or ./.agents/skill/<slug>.
-	base := ".agents"
+	base := skillBase(global)
 	scope := "this project"
 	if global {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "cannot resolve home directory: %v\n", err)
-			os.Exit(1)
-		}
-		base = filepath.Join(home, ".agents")
 		scope = "globally"
 	}
 	dest := filepath.Join(base, "skill", slug)
@@ -117,6 +127,169 @@ func skillInstall(args []string) {
 	fmt.Printf("✓ installed %q → %s\n", slug, dest)
 }
 
+// skillList prints all installed skills (global + project).
+func skillList() {
+	type entry struct {
+		slug  string
+		scope string
+		path  string
+	}
+	var entries []entry
+	dirs := []struct {
+		label string
+		dir   string
+	}{
+		{"global", filepath.Join(skillBase(true), "skill")},
+		{"project", filepath.Join(skillBase(false), "skill")},
+	}
+	for _, d := range dirs {
+		items, err := os.ReadDir(d.dir)
+		if err != nil {
+			continue
+		}
+		for _, e := range items {
+			if e.IsDir() {
+				entries = append(entries, entry{
+					slug:  e.Name(),
+					scope: d.label,
+					path:  filepath.Join(d.dir, e.Name()),
+				})
+			}
+		}
+	}
+	if len(entries) == 0 {
+		fmt.Println("no skills installed")
+		return
+	}
+	fmt.Printf("%-24s %-8s %s\n", "slug", "scope", "path")
+	fmt.Println(strings.Repeat("-", 72))
+	for _, e := range entries {
+		fmt.Printf("%-24s %-8s %s\n", e.slug, e.scope, e.path)
+	}
+}
+
+// skillRemove uninstalls a skill by slug.
+func skillRemove(args []string) {
+	var slug string
+	global := false
+	for _, a := range args {
+		switch a {
+		case "-g", "--global":
+			global = true
+		default:
+			if strings.HasPrefix(a, "-") {
+				fmt.Fprintf(os.Stderr, "unknown flag %q\n", a)
+				os.Exit(1)
+			}
+			slug = a
+		}
+	}
+	if slug == "" {
+		fmt.Fprintln(os.Stderr, "usage: enx skill remove <slug> [-g]")
+		os.Exit(1)
+	}
+	if !validSkillSlug(slug) {
+		fmt.Fprintf(os.Stderr, "invalid skill name %q\n", slug)
+		os.Exit(1)
+	}
+	base := skillBase(global)
+	dest := filepath.Join(base, "skill", slug)
+	if _, err := os.Stat(dest); err != nil {
+		if global {
+			fmt.Fprintf(os.Stderr, "skill %q is not installed globally\n", slug)
+			os.Exit(1)
+		}
+		// Try global as fallback.
+		globalDest := filepath.Join(skillBase(true), "skill", slug)
+		if _, err2 := os.Stat(globalDest); err2 == nil {
+			dest = globalDest
+			global = true
+		} else {
+			fmt.Fprintf(os.Stderr, "skill %q is not installed\n", slug)
+			os.Exit(1)
+		}
+	}
+	scope := "project"
+	if global {
+		scope = "global"
+	}
+	if err := os.RemoveAll(dest); err != nil {
+		fmt.Fprintf(os.Stderr, "remove failed: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("✓ removed %q (%s)\n", slug, scope)
+}
+
+// skillUpdate reinstalls a skill (remove + install).
+func skillUpdate(args []string) {
+	var slug string
+	global := false
+	for _, a := range args {
+		switch a {
+		case "-g", "--global":
+			global = true
+		default:
+			if strings.HasPrefix(a, "-") {
+				fmt.Fprintf(os.Stderr, "unknown flag %q\n", a)
+				os.Exit(1)
+			}
+			slug = a
+		}
+	}
+	if slug == "" {
+		fmt.Fprintln(os.Stderr, "usage: enx skill update <slug> [-g]")
+		os.Exit(1)
+	}
+	if !validSkillSlug(slug) {
+		fmt.Fprintf(os.Stderr, "invalid skill name %q\n", slug)
+		os.Exit(1)
+	}
+	// Check that git is available.
+	if _, err := exec.LookPath("git"); err != nil {
+		fmt.Fprintln(os.Stderr, "git is required to update skills")
+		os.Exit(1)
+	}
+	// Remove existing.
+	base := skillBase(global)
+	dest := filepath.Join(base, "skill", slug)
+	if _, err := os.Stat(dest); err == nil {
+		_ = os.RemoveAll(dest)
+	}
+	// Reinstall.
+	skillInstall(args)
+}
+
+// validSkillSlug reports whether a slug is a safe single path segment (letters,
+// digits, dot, underscore, hyphen) — so it can't escape the skill directory. It
+// mirrors the community skill naming and guards remove/update's RemoveAll.
+func validSkillSlug(slug string) bool {
+	if slug == "" || slug == "." || slug == ".." {
+		return false
+	}
+	for _, r := range slug {
+		switch {
+		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9',
+			r == '-', r == '_', r == '.':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// skillBase returns the base agents directory for global or project scope.
+func skillBase(global bool) string {
+	if global {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "cannot resolve home directory: %v\n", err)
+			os.Exit(1)
+		}
+		return filepath.Join(home, ".agents")
+	}
+	return ".agents"
+}
+
 // copyDir recursively copies src to dst (fallback when os.Rename can't cross fs).
 func copyDir(src, dst string) error {
 	return filepath.Walk(src, func(p string, info os.FileInfo, err error) error {

core/convert/openai.go

@@ -83,6 +83,11 @@ func ToOpenAIChat(req *model.Request) []byte {
 		"model":  req.Model,
 		"stream": req.Stream,
 	}
+	// Ask the upstream to include a usage block in the final SSE chunk so token
+	// counts are available when streaming (needed for accurate accounting).
+	if req.Stream {
+		out["stream_options"] = map[string]any{"include_usage": true}
+	}
 	if req.MaxTokens > 0 {
 		out["max_tokens"] = req.MaxTokens
 	}