mirror of
https://github.com/J3vb/OwnCord.git
synced 2026-09-03 03:50:00 +03:00
Claude
a2cb224323
Phase B Step 6 — Solid.js incremental migration
- vite-plugin-solid + solid-js + @solidjs/testing-library in package.json
- vite.config.ts compiles src/components/solid/** as Solid TSX
- tsconfig.json gains jsx: preserve / jsxImportSource: solid-js
- lib/solidAdapter.ts wraps existing custom Stores as Solid signals
- lib/solidMount.ts adapts Solid render to {mount,destroy} contract
- components/solid/Badge.tsx (proof-of-concept leaf)
- components/solid/ChannelListItem.tsx (store-subscribed leaf)
- components/solid/Badge.test.tsx pipeline smoke test
- components/solid/README.md documents the migration recipe
Phase B Step 7 — Event persistence layer
- SQLite + Postgres migrations for the events table
- sqlc query files for both engines
- EventStore interface + SQLite raw-SQL impl + MemStore impl + pg stubs
- ws.EventPersister: async batched writer (queue / flush / drain / drop)
- ws.StartEventPruner: background retention pruner
- hub persists every replay-buffer push and exposes reconnect-tier counters
- serve.handleReconnect: tiered replay (buffer -> DB -> full re-sync)
- EventPersistenceConfig + main.go wiring
- event_persister_test.go covers batching / drops / drain
Phase B Step 8 — OpenTelemetry skeleton
- Server/telemetry package with public Provider/Tracer/Meter/Counter API
- telemetry_default.go (no-op build) + telemetry_otel.go (build tag otel)
- telemetry/metrics.go declares the AppMetrics bundle
- HTTPMiddleware mounted in Chi router (pass-through in default build)
- PrometheusHandler optionally mounted at /metrics
- Spans on MessageService.SendMessage, PermissionService.HasChannelPerm,
ChannelService.ListVisibleChannels
- Reconnect-tier counter wired into the global meter
- TelemetryConfig defaults
Phase C Step 9 — Wazero plugin runtime skeleton
- Server/plugin package: manifest parser, loader, registry, host APIs
(commands, storage, events, http, ui), errors
- sandbox_default.go (no-op) + sandbox_wazero.go (build tag wazero)
- SQLite + Postgres migrations for plugins + plugin_kv tables
- PluginStore interface + impls + pg stubs
- plugin/examples/hello manifest + README
- plugin_test.go covers manifest, loader, capability gating
- api/plugins_handler.go admin REST surface, mounted under admin group
- PluginsConfig + main.go wiring (disabled by default)
- Client: lib/pluginBridge.ts iframe + postMessage host
- Client: components/solid/PluginContainer.tsx Solid host component
Verification
- Default build (no -tags) is intended to compile cleanly with no new
third-party dependencies. The sandbox lacked Go 1.25.0 so go build
could not run; PHASE_BC_LOCAL_TODO.md enumerates the local follow-up
work (npm install, go mod tidy, sqlc-generate, real otel/wazero
wiring, remaining service spans, full Solid migration).
64 lines
2.2 KiB
Go
64 lines
2.2 KiB
Go
// Phase C Step 9 — `commands` host capability.
|
|
//
|
|
// Plugins that declare the "commands" capability register one or more slash
|
|
// commands at activation time. The WS command dispatcher (Server/ws/command.go)
|
|
// calls Registry.DispatchCommand after exhausting its built-in command table.
|
|
package plugin
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// CommandResult is what a plugin returns from a command invocation.
|
|
type CommandResult struct {
|
|
// Reply is sent back to the invoking user as an ephemeral message.
|
|
Reply string
|
|
// Broadcast, when set, is also broadcast to the channel.
|
|
Broadcast string
|
|
}
|
|
|
|
// RegisterCommand binds cmd to inst. Called from the activation path in the
|
|
// wazero-tagged build once the module exports its `register_commands` table.
|
|
// Default build can call it directly from tests.
|
|
func (r *Registry) RegisterCommand(cmd string, inst *Instance) error {
|
|
cmd = strings.ToLower(strings.TrimPrefix(cmd, "/"))
|
|
if cmd == "" {
|
|
return fmt.Errorf("plugin: cannot register empty command")
|
|
}
|
|
if !inst.Manifest.HasCapability(CapCommands) {
|
|
return ErrCapabilityNotGranted
|
|
}
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if existing, ok := r.commands[cmd]; ok && existing != inst {
|
|
return fmt.Errorf("plugin: command %q already registered by %q", cmd, existing.Manifest.Name)
|
|
}
|
|
r.commands[cmd] = inst
|
|
return nil
|
|
}
|
|
|
|
// DispatchCommand routes a slash command to the owning plugin. Returns
|
|
// (nil, false) when no plugin owns the command, letting the WS dispatcher
|
|
// fall back to the not-found response. Returns (nil, true) when the runtime
|
|
// is unavailable so the dispatcher can show a helpful error message.
|
|
func (r *Registry) DispatchCommand(ctx context.Context, userID int64, channelID int64, cmd string, args []string) (*CommandResult, bool) {
|
|
if r == nil {
|
|
return nil, false
|
|
}
|
|
cmd = strings.ToLower(strings.TrimPrefix(cmd, "/"))
|
|
r.mu.RLock()
|
|
inst, ok := r.commands[cmd]
|
|
r.mu.RUnlock()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
if r.runtimePlatform == nil {
|
|
return &CommandResult{
|
|
Reply: fmt.Sprintf("plugin %q owns /%s but the wazero runtime is not built (run with -tags wazero)", inst.Manifest.Name, cmd),
|
|
}, true
|
|
}
|
|
return r.invokeCommand(ctx, inst, userID, channelID, cmd, args)
|
|
}
|