claude-smart 0.2.45 → 0.2.46

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_state.py

@@ -0,0 +1,235 @@
+"""Tests for openclaw_smart.state."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from openclaw_smart import state
+
+
+@pytest.fixture(autouse=True)
+def isolate_state_dir(monkeypatch, tmp_path):
+    """Each test gets its own state dir via OPENCLAW_SMART_STATE_DIR."""
+    sessions = tmp_path / "sessions"
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(sessions))
+    return sessions
+
+
+def test_state_dir_honours_env(isolate_state_dir):
+    assert state.state_dir() == isolate_state_dir
+
+
+def test_append_creates_file(isolate_state_dir):
+    state.append("sess1", {"role": "User", "content": "hi"})
+    path = isolate_state_dir / "sess1.jsonl"
+    assert path.exists()
+    lines = path.read_text().strip().splitlines()
+    assert len(lines) == 1
+    assert json.loads(lines[0])["content"] == "hi"
+
+
+def test_read_all_returns_records():
+    state.append("sess2", {"role": "User", "content": "a"})
+    state.append("sess2", {"role": "Assistant", "content": "b"})
+    records = state.read_all("sess2")
+    assert len(records) == 2
+    assert records[0]["content"] == "a"
+    assert records[1]["content"] == "b"
+
+
+def test_read_all_missing_file_returns_empty():
+    assert state.read_all("never-existed") == []
+
+
+def test_read_all_skips_malformed_lines(isolate_state_dir):
+    isolate_state_dir.mkdir(parents=True, exist_ok=True)
+    path = isolate_state_dir / "broken.jsonl"
+    path.write_text(
+        '{"role": "User", "content": "good"}\nnot json\n{"role": "Assistant", "content": "also good"}\n'
+    )
+    records = state.read_all("broken")
+    assert len(records) == 2
+    assert records[0]["content"] == "good"
+    assert records[1]["content"] == "also good"
+
+
+def test_unpublished_slice_returns_watermark_and_turns():
+    state.append("s3", {"role": "User", "content": "1"})
+    state.append("s3", {"role": "Assistant", "content": "2"})
+    state.append("s3", {"published_up_to": 2})
+    state.append("s3", {"role": "User", "content": "3"})
+    state.append("s3", {"role": "Assistant", "content": "4"})
+    records = state.read_all("s3")
+    watermark, turns = state.unpublished_slice(records)
+    assert watermark == 2
+    contents = [t["content"] for t in turns]
+    assert contents == ["3", "4"]
+
+
+def test_unpublished_slice_folds_tool_records():
+    records = [
+        {"role": "User", "content": "run ls"},
+        {
+            "role": "Assistant_tool",
+            "tool_name": "Bash",
+            "tool_input": {"command": "ls"},
+            "tool_output": "a.txt",
+            "status": "success",
+        },
+        {"role": "Assistant", "content": "Done."},
+    ]
+    _, turns = state.unpublished_slice(records)
+    assert len(turns) == 2
+    assert turns[0]["role"] == "User"
+    assistant_turn = turns[1]
+    assert assistant_turn["role"] == "Assistant"
+    assert assistant_turn["tools_used"] == [
+        {
+            "tool_name": "Bash",
+            "status": "success",
+            "tool_data": {
+                "input": {"command": "ls"},
+                "output": "a.txt",
+            },
+        }
+    ]
+
+
+def test_unpublished_slice_truncates_long_tool_fields():
+    long_value = "x" * 500
+    records = [
+        {
+            "role": "Assistant_tool",
+            "tool_name": "Edit",
+            "tool_input": {"new_string": long_value},
+            "tool_output": "",
+            "status": "success",
+        },
+        {"role": "Assistant", "content": "ok"},
+    ]
+    _, turns = state.unpublished_slice(records)
+    truncated = turns[0]["tools_used"][0]["tool_data"]["input"]["new_string"]
+    assert len(truncated) == 256
+    assert truncated == "x" * 256
+
+
+def test_unpublished_slice_ignores_malformed_watermark_and_tool_input():
+    records = [
+        {"published_up_to": "not-an-int"},
+        {
+            "role": "Assistant_tool",
+            "tool_name": "Bash",
+            "tool_input": ["not", "a", "mapping"],
+            "tool_output": "ok",
+        },
+        {"role": "Assistant", "content": "Done."},
+    ]
+
+    watermark, turns = state.unpublished_slice(records)
+
+    assert watermark == 0
+    assert turns == [
+        {
+            "role": "Assistant",
+            "content": "Done.",
+            "tools_used": [
+                {
+                    "tool_name": "Bash",
+                    "status": "success",
+                    "tool_data": {"output": "ok"},
+                }
+            ],
+        }
+    ]
+
+
+def test_unpublished_slice_ignores_out_of_range_watermark():
+    # A marker larger than the records seen before it (e.g. a corrupt/tampered
+    # buffer) must be ignored, not applied — otherwise the ``idx < published``
+    # gate would skip every later turn and silently drop unpublished records.
+    records = [
+        {"published_up_to": 99},
+        {"role": "Assistant", "content": "Hello."},
+    ]
+
+    watermark, turns = state.unpublished_slice(records)
+
+    assert watermark == 0
+    assert turns == [{"role": "Assistant", "content": "Hello."}]
+
+
+def test_append_injected_writes_registry():
+    state.append_injected(
+        "s4",
+        [
+            {"id": "s1-abcd", "kind": "skill", "title": "Test skill", "real_id": "abc"},
+            {
+                "id": "p1-efgh",
+                "kind": "preference",
+                "title": "Test pref",
+                "real_id": "def",
+            },
+        ],
+    )
+    registry = state.read_injected("s4")
+    assert set(registry) == {"s1-abcd", "p1-efgh"}
+    assert registry["s1-abcd"]["title"] == "Test skill"
+
+
+def test_append_injected_noop_when_empty():
+    state.append_injected("s5", [])
+    assert state.read_injected("s5") == {}
+
+
+def test_read_injected_later_wins():
+    state.append_injected("s6", [{"id": "s1-abcd", "title": "old"}])
+    state.append_injected("s6", [{"id": "s1-abcd", "title": "new"}])
+    registry = state.read_injected("s6")
+    assert registry["s1-abcd"]["title"] == "new"
+
+
+def test_path_traversal_session_id_rejected(isolate_state_dir, tmp_path):
+    """A crafted session id with path separators must not escape state_dir()."""
+    escape_attempts = [
+        "../escape",
+        "../../etc/passwd",
+        "a/b/c",
+        "sub/sess",
+        "..",
+        "",
+        "a" * 200,  # over 128 char cap
+    ]
+    for sid in escape_attempts:
+        assert state.session_path(sid) is None, f"unsafe session_path accepted: {sid!r}"
+        assert state.injected_path(sid) is None
+        # Append + read must silently no-op rather than writing anywhere.
+        state.append(sid, {"role": "User", "content": "x"})
+        state.append_injected(sid, [{"id": "s1-abcd", "title": "x"}])
+        assert state.read_all(sid) == []
+        assert state.read_injected(sid) == {}
+
+    # The state dir itself should remain empty — nothing escaped.
+    if isolate_state_dir.exists():
+        assert not any(isolate_state_dir.glob("**/*.jsonl"))
+    # And nowhere outside it either.
+    assert not (tmp_path / "escape.jsonl").exists()
+
+
+def test_safe_session_ids_accepted():
+    """The safe-id charset (alphanumeric + dot/underscore/hyphen/colon) is allowed."""
+    # Colons appear in real openClaw sessionKeys (``agent:main:main``); they're
+    # not POSIX path separators so they're safe inside filenames.
+    for sid in (
+        "sess1",
+        "a.b.c",
+        "a_b",
+        "a-b",
+        "01234",
+        "S.1_2-3",
+        "agent:main:main",
+        "agent:work:abc123",
+    ):
+        path = state.session_path(sid)
+        assert path is not None, f"safe id {sid!r} should have been accepted"
+        assert path.name == f"{sid}.jsonl"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests-ts/__mocks__/plugin-entry-stub.ts

@@ -0,0 +1,6 @@
+// Test-only stub for "openclaw/plugin-sdk/plugin-entry". The real module
+// ships with the openclaw host runtime; under vitest we provide a
+// passthrough so plugin definitions can be exercised in isolation.
+export function definePluginEntry<T>(def: T): T {
+  return def;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests-ts/test_npm_cli.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const CLI = resolve("scripts/npm-cli.js");
+
+function runCli(args: string[], env: Record<string, string>) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    cwd: resolve("."),
+    env: { ...process.env, ...env },
+    encoding: "utf8",
+  });
+}
+
+describe("openclaw-smart npm CLI", () => {
+  it("prints help", () => {
+    const result = runCli(["--help"], {});
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("openclaw-smart install");
+  });
+
+  it("installs through openclaw and persists OPENCLAW_BIN", () => {
+    const home = mkdtempSync(join(tmpdir(), "openclaw-smart-home-"));
+    const bin = mkdtempSync(join(tmpdir(), "openclaw-smart-bin-"));
+    const log = join(home, "openclaw.log");
+    const fakeOpenClaw = join(bin, "openclaw");
+    const fakeBash = join(bin, "bash");
+
+    writeFileSync(
+      fakeOpenClaw,
+      `#!/usr/bin/env sh\nprintf '%s\\n' "$*" >> "${log}"\nif [ "$1 $2" = "plugins inspect" ]; then printf 'Status: loaded\\n'; fi\nexit 0\n`,
+    );
+    writeFileSync(fakeBash, "#!/usr/bin/env sh\nexit 0\n");
+    chmodSync(fakeOpenClaw, 0o755);
+    chmodSync(fakeBash, 0o755);
+
+    const result = runCli(["install"], {
+      HOME: home,
+      PATH: `${bin}:${process.env.PATH ?? ""}`,
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("openclaw-smart installed and registered");
+    expect(readFileSync(join(home, ".reflexio", ".env"), "utf8")).toContain(
+      `OPENCLAW_BIN="${fakeOpenClaw}"`,
+    );
+    const calls = readFileSync(log, "utf8");
+    expect(calls).toContain("plugins install");
+    expect(calls).toContain(
+      "config set plugins.entries.reflexio-openclaw-smart.hooks.allowConversationAccess true",
+    );
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests-ts/test_shim_dispatch.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EventEmitter } from "node:events";
+
+// Mock node:child_process.spawn before importing the plugin so the shim's
+// runScript() helper goes through our fake instead of a real subprocess.
+type FakeProcShape = {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  /** When true, the simulated process never emits 'close' so the runScript timeout fires. */
+  hang?: boolean;
+};
+
+const fakeProc: { current: FakeProcShape } = {
+  current: { stdout: "", stderr: "", code: 0 },
+};
+
+const lastSpawn: { cmd?: string; args?: string[]; input?: string } = {};
+
+vi.mock("node:child_process", () => ({
+  spawn: (cmd: string, args: string[]) => {
+    lastSpawn.cmd = cmd;
+    lastSpawn.args = args;
+    const child = new EventEmitter() as EventEmitter & {
+      stdout: EventEmitter;
+      stderr: EventEmitter;
+      stdin: { write: (s: string) => void; end: () => void };
+      kill: (signal?: string) => void;
+    };
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.stdin = {
+      write: (s: string) => {
+        lastSpawn.input = s;
+      },
+      end: () => {},
+    };
+    child.kill = () => {
+      child.emit("close", null);
+    };
+
+    if (!fakeProc.current.hang) {
+      // Defer to next tick so listeners attached after spawn() are wired up
+      // before we start emitting.
+      setImmediate(() => {
+        if (fakeProc.current.stdout) {
+          child.stdout.emit("data", Buffer.from(fakeProc.current.stdout));
+        }
+        if (fakeProc.current.stderr) {
+          child.stderr.emit("data", Buffer.from(fakeProc.current.stderr));
+        }
+        child.emit("close", fakeProc.current.code);
+      });
+    }
+    return child;
+  },
+}));
+
+// Import AFTER vi.mock so the plugin captures the mocked spawn.
+const { default: plugin } = await import("../index.ts");
+
+beforeEach(() => {
+  fakeProc.current = { stdout: "", stderr: "", code: 0 };
+  lastSpawn.cmd = undefined;
+  lastSpawn.args = undefined;
+  lastSpawn.input = undefined;
+});
+
+describe("openclaw-smart TS shim", () => {
+  it("registers the empirically-verified hook set without touching runtime.system", async () => {
+    const onCalls: string[] = [];
+    // Intentionally omit runtime.system to match the untrusted-plugin reality
+    // — if the plugin ever reaches for it, register() crashes here.
+    const api = {
+      logger: {},
+      runtime: {},
+      pluginConfig: {},
+      registerTool: vi.fn(),
+      on: (name: string, _h: unknown) => {
+        onCalls.push(name);
+      },
+    };
+    await plugin.register(api as never);
+    expect(onCalls).toEqual([
+      "session_start",
+      "message_received",
+      "before_prompt_build",
+      "before_tool_call",
+      "after_tool_call",
+      "agent_end",
+      "session_end",
+    ]);
+  });
+
+  it("does not register agent tools (hook-only plugin)", async () => {
+    // Registering tools requires a manifest contracts.tools declaration;
+    // we intentionally keep the surface skill-only so register() never
+    // touches api.registerTool. The `learn` skill is the equivalent path.
+    const reg = vi.fn();
+    const api = {
+      logger: {},
+      runtime: {},
+      pluginConfig: {},
+      registerTool: reg,
+      on: vi.fn(),
+    };
+    await plugin.register(api as never);
+    expect(reg).not.toHaveBeenCalled();
+  });
+
+  it("forwards a hook payload via bash + spawn and parses JSON stdout", async () => {
+    fakeProc.current = {
+      stdout: '{"prependContext":"hi"}',
+      stderr: "",
+      code: 0,
+    };
+    const handlers: Record<string, Function> = {};
+    const api = {
+      logger: {},
+      runtime: {},
+      pluginConfig: {},
+      registerTool: vi.fn(),
+      on: (name: string, h: Function) => {
+        handlers[name] = h;
+      },
+    };
+    await plugin.register(api as never);
+    const result = await handlers["session_start"]({}, { sessionKey: "s1" });
+    expect(result).toEqual({ prependContext: "hi" });
+    expect(lastSpawn.cmd).toBe("bash");
+    expect(lastSpawn.args).toEqual(
+      expect.arrayContaining([expect.stringMatching(/hook_entry\.sh$/), "openclaw", "session-start"]),
+    );
+    expect(lastSpawn.input).toBeDefined();
+    expect(JSON.parse(lastSpawn.input!)).toMatchObject({ sessionKey: "s1" });
+  });
+
+  it("returns undefined when subprocess exits non-zero", async () => {
+    fakeProc.current = { stdout: "", stderr: "boom", code: 1 };
+    const handlers: Record<string, Function> = {};
+    const api = {
+      logger: { debug: vi.fn() },
+      runtime: {},
+      pluginConfig: {},
+      registerTool: vi.fn(),
+      on: (name: string, h: Function) => {
+        handlers[name] = h;
+      },
+    };
+    await plugin.register(api as never);
+    const result = await handlers["session_start"]({}, {});
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined on empty stdout (no-op event)", async () => {
+    fakeProc.current = { stdout: "", stderr: "", code: 0 };
+    const handlers: Record<string, Function> = {};
+    const api = {
+      logger: { debug: vi.fn() },
+      runtime: {},
+      pluginConfig: {},
+      registerTool: vi.fn(),
+      on: (name: string, h: Function) => {
+        handlers[name] = h;
+      },
+    };
+    await plugin.register(api as never);
+    const result = await handlers["before_tool_call"]({}, {});
+    expect(result).toBeUndefined();
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tsconfig.build.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": false,
+    "declaration": false,
+    "sourceMap": false,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "types": ["node"]
+  },
+  "include": ["index.ts", "types/**/*.d.ts"],
+  "exclude": ["node_modules", "src", "tests", "tests-ts", "scripts", "dist"]
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/{tsconfig.json → plugin/tsconfig.json}

@@ -11,6 +11,6 @@
     "resolveJsonModule": true,
     "types": ["node"]
   },
-  "include": ["plugin/**/*.ts", "types/**/*.d.ts"],
-  "exclude": ["tests", "node_modules"]
+  "include": ["index.ts", "tests-ts/**/*.ts", "types/**/*.d.ts"],
+  "exclude": ["node_modules", "src", "tests", "scripts"]
 }