391 lines
15 KiB
Go
391 lines
15 KiB
Go
package plugins
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestKimiRegistryUsesModernGlobalContract(t *testing.T) {
|
|
entry := SupportedAgents[kimiAgentKey]
|
|
if entry.Name != "Kimi Code" || entry.ConfigDir != "~/.kimi-code" || entry.ConfigFile != "config.toml" {
|
|
t.Fatalf("Kimi registry entry = %#v", entry)
|
|
}
|
|
if _, ok := NewPlugin(kimiAgentKey).(*KimiPlugin); !ok {
|
|
t.Fatalf("Kimi registry plugin = %T", NewPlugin(kimiAgentKey))
|
|
}
|
|
}
|
|
|
|
func TestKimiInstallPreservesBothConfigsAndIsIdempotent(t *testing.T) {
|
|
modern := "# modern user config\ndefault_model = \"kimi-code/k3\"\n\n" +
|
|
"[[hooks]]\nevent = \"SessionStart\"\ncommand = \"existing-modern\"\n" +
|
|
"timeout = 30 # keep modern hook\n"
|
|
legacy := "# legacy user config\ntelemetry = false\n\n" +
|
|
"[[hooks]]\nevent = \"SessionEnd\"\ncommand = \"existing-legacy\"\n"
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
modernConfig: kimiString(modern),
|
|
legacyConfig: kimiString(legacy),
|
|
})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("repeat Kimi install: %v", err)
|
|
}
|
|
|
|
for _, contract := range []struct{ path, comment, command string }{
|
|
{fixture.modernPath, "# modern user config", "existing-modern"},
|
|
{fixture.legacyPath, "# legacy user config", "existing-legacy"},
|
|
} {
|
|
raw, err := os.ReadFile(contract.path)
|
|
if err != nil {
|
|
t.Fatalf("read Kimi config: %v", err)
|
|
}
|
|
if !strings.Contains(string(raw), contract.comment) || !strings.Contains(string(raw), contract.command) {
|
|
t.Fatalf("user config changed: %s", raw)
|
|
}
|
|
hooks := readKimiTestHooks(t, contract.path)
|
|
if len(hooks) != 3 {
|
|
t.Fatalf("hooks = %#v, want three entries", hooks)
|
|
}
|
|
requireStrictKimiHook(t, findKimiTestHook(t, hooks, "PreToolUse", kimiGuardScript))
|
|
requireStrictKimiHook(t, findKimiTestHook(t, hooks, "PostToolUse", kimiAuditScript))
|
|
}
|
|
defaultModern := filepath.Join(fixture.homeDir, ".kimi-code", "config.toml")
|
|
if _, err := os.Stat(defaultModern); !os.IsNotExist(err) {
|
|
t.Fatalf("false default migration target exists: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestKimiInstallPreservesInlineHookArrayStyle(t *testing.T) {
|
|
modern := "# inline user hook\nhooks = [\n # keep leading\n { event = \"SessionStart\", " +
|
|
"command = \"existing-inline\" }, # keep gap\n] # keep array\n"
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
modernConfig: kimiString(modern),
|
|
withoutLegacyCLI: true,
|
|
})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install inline Kimi hooks: %v", err)
|
|
}
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("repeat inline Kimi install: %v", err)
|
|
}
|
|
raw, err := os.ReadFile(fixture.modernPath)
|
|
if err != nil {
|
|
t.Fatalf("read inline Kimi config: %v", err)
|
|
}
|
|
for _, marker := range []string{
|
|
"# inline user hook",
|
|
"# keep leading",
|
|
"# keep gap",
|
|
"# keep array",
|
|
"hooks = [",
|
|
} {
|
|
if !strings.Contains(string(raw), marker) {
|
|
t.Fatalf("inline marker %q missing from %s", marker, raw)
|
|
}
|
|
}
|
|
if len(readKimiTestHooks(t, fixture.modernPath)) != 3 {
|
|
t.Fatalf("inline Kimi hooks are not idempotent: %s", raw)
|
|
}
|
|
}
|
|
|
|
func TestKimiModernDefaultAvoidsLegacyMigrationMarker(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
useDefaultHome: true,
|
|
withoutLegacyCLI: true,
|
|
})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install modern Kimi hooks: %v", err)
|
|
}
|
|
if len(readKimiTestHooks(t, fixture.modernPath)) != 2 {
|
|
t.Fatalf("modern Kimi config has unexpected hooks")
|
|
}
|
|
if _, err := os.Stat(fixture.legacyPath); !os.IsNotExist(err) {
|
|
t.Fatalf("false legacy migration target exists: %v", err)
|
|
}
|
|
status, err := fixture.plugin.Status()
|
|
if err != nil || !status.Installed {
|
|
t.Fatalf("empty KIMI_CODE_HOME status = %#v, %v", status, err)
|
|
}
|
|
}
|
|
|
|
func TestKimiLegacyInstallAvoidsPrematureModernTarget(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{useDefaultHome: true})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install legacy Kimi hooks: %v", err)
|
|
}
|
|
if len(readKimiTestHooks(t, fixture.legacyPath)) != 2 {
|
|
t.Fatalf("legacy Kimi config has unexpected hooks")
|
|
}
|
|
if _, err := os.Stat(fixture.modernPath); !os.IsNotExist(err) {
|
|
t.Fatalf("premature modern migration target exists: %v", err)
|
|
}
|
|
if err := os.Remove(fixture.legacyCLIPath); err != nil {
|
|
t.Fatalf("remove legacy CLI marker: %v", err)
|
|
}
|
|
status, err := fixture.plugin.Status()
|
|
if err != nil || !status.Installed {
|
|
t.Fatalf("legacy status after PATH change = %#v, %v", status, err)
|
|
}
|
|
}
|
|
|
|
func TestKimiCommandsBlockAndForwardOfficialPayload(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
capturePath := filepath.Join(t.TempDir(), "captured-event.json")
|
|
encodedPath, err := json.Marshal(capturePath)
|
|
if err != nil {
|
|
t.Fatalf("marshal capture path: %v", err)
|
|
}
|
|
source := "const fs = require('node:fs'); const chunks = []; " +
|
|
"process.stdin.on('data', chunk => chunks.push(chunk)); " +
|
|
"process.stdin.on('end', () => fs.writeFileSync(" + string(encodedPath) + ", Buffer.concat(chunks)));\n"
|
|
if err := os.WriteFile(fixture.hookPath, []byte(source), 0700); err != nil {
|
|
t.Fatalf("write capture runtime: %v", err)
|
|
}
|
|
hooks := readKimiTestHooks(t, fixture.modernPath)
|
|
payload := map[string]any{
|
|
"hook_event_name": "PreToolUse",
|
|
"session_id": "session-1",
|
|
"cwd": fixture.homeDir,
|
|
"tool_name": "Bash",
|
|
"tool_input": map[string]any{"command": "echo test"},
|
|
"tool_call_id": "call-1",
|
|
}
|
|
guard := findKimiTestHook(t, hooks, "PreToolUse", kimiGuardScript)
|
|
exitCode, stderr := runKimiCommand(t, guard["command"].(string), fixture.homeDir, payload)
|
|
if exitCode != 2 || !strings.Contains(stderr, "Agent is frozen by Elydora") {
|
|
t.Fatalf("guard exit = %d, stderr = %q", exitCode, stderr)
|
|
}
|
|
payload["hook_event_name"] = "PostToolUse"
|
|
payload["tool_output"] = map[string]any{"output": "test"}
|
|
audit := findKimiTestHook(t, hooks, "PostToolUse", kimiAuditScript)
|
|
exitCode, stderr = runKimiCommand(t, audit["command"].(string), fixture.homeDir, payload)
|
|
if exitCode != 0 {
|
|
t.Fatalf("audit exit = %d, stderr = %q", exitCode, stderr)
|
|
}
|
|
capturedRaw, err := os.ReadFile(capturePath)
|
|
if err != nil {
|
|
t.Fatalf("read captured event: %v", err)
|
|
}
|
|
var captured map[string]any
|
|
if err := json.Unmarshal(capturedRaw, &captured); err != nil {
|
|
t.Fatalf("decode captured event: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(captured, payload) {
|
|
t.Fatalf("captured event = %#v, want %#v", captured, payload)
|
|
}
|
|
}
|
|
|
|
func TestKimiStatusAcceptsEitherContractAndRequiresBothScripts(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := os.Remove(fixture.modernPath); err != nil {
|
|
t.Fatalf("remove modern config: %v", err)
|
|
}
|
|
requireKimiInstalledStatus(t, fixture.plugin, fixture.legacyPath)
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("reinstall Kimi hooks: %v", err)
|
|
}
|
|
if err := os.Remove(fixture.legacyPath); err != nil {
|
|
t.Fatalf("remove legacy config: %v", err)
|
|
}
|
|
requireKimiInstalledStatus(t, fixture.plugin, fixture.modernPath)
|
|
if err := os.Remove(fixture.guardPath); err != nil {
|
|
t.Fatalf("remove Kimi guard: %v", err)
|
|
}
|
|
status, err := fixture.plugin.Status()
|
|
if err != nil || status.Installed || !status.HookConfigured || status.HookScriptExists {
|
|
t.Fatalf("degraded Kimi status = %#v, %v", status, err)
|
|
}
|
|
}
|
|
|
|
func requireKimiInstalledStatus(t *testing.T, plugin *KimiPlugin, configPath string) {
|
|
t.Helper()
|
|
status, err := plugin.Status()
|
|
if err != nil || !status.Installed || status.ConfigPath != configPath {
|
|
t.Fatalf("Kimi status = %#v, %v; want installed at %s", status, err, configPath)
|
|
}
|
|
}
|
|
|
|
func TestKimiUninstallPreservesUserHooks(t *testing.T) {
|
|
userHook := "# user hook\n[[hooks]]\nevent = \"SessionStart\"\n" +
|
|
"command = \"existing-command\"\ntimeout = 30 # keep timeout\n"
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
modernConfig: kimiString(userHook),
|
|
legacyConfig: kimiString(userHook),
|
|
})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := fixture.plugin.Uninstall(kimiTestAgentID); err != nil {
|
|
t.Fatalf("uninstall Kimi hooks: %v", err)
|
|
}
|
|
for _, path := range []string{fixture.modernPath, fixture.legacyPath} {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("read user config after uninstall: %v", err)
|
|
}
|
|
if !strings.Contains(string(raw), "# user hook") || !strings.Contains(string(raw), "# keep timeout") {
|
|
t.Fatalf("user comments changed: %s", raw)
|
|
}
|
|
hooks := readKimiTestHooks(t, path)
|
|
if len(hooks) != 1 || hooks[0]["command"] != "existing-command" {
|
|
t.Fatalf("user hook changed: %#v", hooks)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestKimiOwnershipRequiresExactAgentAndScript(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
backupPath := filepath.Join(fixture.homeDir, ".elydora", kimiTestAgentID, "hook.js.backup")
|
|
otherAgentPath := filepath.Join(fixture.homeDir, ".elydora", "agent-10", kimiAuditScript)
|
|
userHooks := "[[hooks]]\nevent = \"PostToolUse\"\ncommand = " +
|
|
strconv.Quote("node "+backupPath) + "\n\n[[hooks]]\nevent = \"PostToolUse\"\ncommand = " +
|
|
strconv.Quote("node "+otherAgentPath) + "\n"
|
|
if err := os.MkdirAll(filepath.Dir(fixture.modernPath), 0755); err != nil {
|
|
t.Fatalf("create modern Kimi directory: %v", err)
|
|
}
|
|
if err := os.WriteFile(fixture.modernPath, []byte(userHooks), 0600); err != nil {
|
|
t.Fatalf("write ownership fixture: %v", err)
|
|
}
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := fixture.plugin.Uninstall(kimiTestAgentID); err != nil {
|
|
t.Fatalf("uninstall Kimi hooks: %v", err)
|
|
}
|
|
hooks := readKimiTestHooks(t, fixture.modernPath)
|
|
if len(hooks) != 2 {
|
|
t.Fatalf("ownership filter removed user hooks: %#v", hooks)
|
|
}
|
|
commands := []any{hooks[0]["command"], hooks[1]["command"]}
|
|
if !reflect.DeepEqual(commands, []any{"node " + backupPath, "node " + otherAgentPath}) {
|
|
t.Fatalf("remaining commands = %#v", commands)
|
|
}
|
|
}
|
|
|
|
func TestKimiUninstallRemovesOwnedConfigs(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := fixture.plugin.Uninstall(kimiTestAgentID); err != nil {
|
|
t.Fatalf("uninstall Kimi hooks: %v", err)
|
|
}
|
|
for _, path := range []string{fixture.modernPath, fixture.legacyPath} {
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
t.Fatalf("owned Kimi config remains at %s: %v", path, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestKimiParsesEveryConfigBeforeRuntimeWrites(t *testing.T) {
|
|
modern := "# untouched modern\ndefault_model = \"kimi-code/k3\"\n"
|
|
legacy := "[malformed"
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
modernConfig: kimiString(modern),
|
|
legacyConfig: kimiString(legacy),
|
|
})
|
|
err := fixture.plugin.Install(fixture.config)
|
|
if err == nil || !strings.Contains(err.Error(), "parse kimi-cli legacy hooks config") {
|
|
t.Fatalf("install error = %v", err)
|
|
}
|
|
for path, want := range map[string]string{fixture.modernPath: modern, fixture.legacyPath: legacy} {
|
|
raw, readErr := os.ReadFile(path)
|
|
if readErr != nil || string(raw) != want {
|
|
t.Fatalf("config %s changed: %q, %v", path, raw, readErr)
|
|
}
|
|
}
|
|
requireNoKimiRuntimeWrites(t, fixture)
|
|
}
|
|
|
|
func TestKimiRejectsInvalidHookContractsBeforeWrites(t *testing.T) {
|
|
for _, testCase := range []struct{ name, raw, want string }{
|
|
{"unsupported-field", "[[hooks]]\nevent=\"PreToolUse\"\ncommand=\"x\"\ncwd=\"/tmp\"\n", `unsupported field "cwd"`},
|
|
{"unsupported-event", "[[hooks]]\nevent=\"Interrupt\"\ncommand=\"x\"\n", "unsupported event"},
|
|
{"bad-matcher", "[[hooks]]\nevent=\"PreToolUse\"\ncommand=\"x\"\nmatcher=1\n", "matcher must be a string"},
|
|
{"bad-timeout", "[[hooks]]\nevent=\"PreToolUse\"\ncommand=\"x\"\ntimeout=601\n", "integer from 1 to 600"},
|
|
{"hooks-object", "hooks = { event=\"PreToolUse\", command=\"x\" }\n", `field "hooks" must be an array`},
|
|
} {
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{
|
|
useDefaultHome: true,
|
|
legacyConfig: kimiString(testCase.raw),
|
|
})
|
|
err := fixture.plugin.Install(fixture.config)
|
|
if err == nil || !strings.Contains(err.Error(), testCase.want) {
|
|
t.Fatalf("install error = %v, want %q", err, testCase.want)
|
|
}
|
|
raw, readErr := os.ReadFile(fixture.legacyPath)
|
|
if readErr != nil || string(raw) != testCase.raw {
|
|
t.Fatalf("invalid config changed: %q, %v", raw, readErr)
|
|
}
|
|
requireNoKimiRuntimeWrites(t, fixture)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestKimiRejectsMissingGuardBeforeWrites(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{withoutGuard: true})
|
|
err := fixture.plugin.Install(fixture.config)
|
|
if err == nil || !strings.Contains(err.Error(), "guard runtime is missing") {
|
|
t.Fatalf("install error = %v", err)
|
|
}
|
|
for _, path := range []string{fixture.modernPath, fixture.legacyPath} {
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
t.Fatalf("config write occurred at %s: %v", path, err)
|
|
}
|
|
}
|
|
requireNoKimiRuntimeWrites(t, fixture)
|
|
}
|
|
|
|
func requireNoKimiRuntimeWrites(t *testing.T, fixture *kimiFixture) {
|
|
t.Helper()
|
|
for _, path := range []string{fixture.hookPath, fixture.runtimeConfig, fixture.privateKey} {
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
t.Fatalf("runtime write occurred at %s: %v", path, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestKimiStatusSurfacesMalformedRuntimeMetadata(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
if err := os.WriteFile(fixture.runtimeConfig, []byte("{ malformed"), 0600); err != nil {
|
|
t.Fatalf("corrupt runtime config: %v", err)
|
|
}
|
|
if _, err := fixture.plugin.Status(); err == nil || !strings.Contains(err.Error(), "parse Elydora runtime config") {
|
|
t.Fatalf("status error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestKimiAtomicWritesLeaveNoTemporaryFiles(t *testing.T) {
|
|
fixture := prepareKimiFixture(t, kimiFixtureOptions{})
|
|
if err := fixture.plugin.Install(fixture.config); err != nil {
|
|
t.Fatalf("install Kimi hooks: %v", err)
|
|
}
|
|
for _, directory := range []string{filepath.Dir(fixture.modernPath), filepath.Dir(fixture.legacyPath)} {
|
|
entries, err := os.ReadDir(directory)
|
|
if err != nil {
|
|
t.Fatalf("read config directory: %v", err)
|
|
}
|
|
for _, entry := range entries {
|
|
if strings.HasSuffix(entry.Name(), ".tmp") {
|
|
t.Fatalf("temporary Kimi config remains at %s", filepath.Join(directory, entry.Name()))
|
|
}
|
|
}
|
|
}
|
|
}
|