claude-smart 0.2.44 → 0.2.46

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/cli.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Wrapper for slash commands that invoke the openclaw_smart CLI via uv.
+# openClaw runs `!` bash directives in slash command .md files in a
+# non-interactive, non-login shell that does NOT source ~/.zshrc or
+# ~/.bash_profile. As a result, binaries installed by smart-install.sh
+# at ~/.local/bin (e.g. uv from the astral.sh installer) are invisible
+# to those directives until the user manually re-sources their shell rc.
+# This wrapper bootstraps PATH the same way hook_entry.sh does so the
+# slash commands work on a fresh install.
+set -eu
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=_lib.sh
+. "$HERE/_lib.sh"
+openclaw_smart_source_login_path
+openclaw_smart_prepend_astral_bins
+openclaw_smart_prepend_node_bins
+
+PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+
+# If the Setup hook recorded an install failure, surface that reason
+# instead of falling through to a generic "uv not found" — mirrors the
+# branch at hook_entry.sh so slash commands and hooks behave consistently
+# on a broken install.
+FAILURE_MARKER="$HOME/.openclaw-smart/install-failed"
+if [ -f "$FAILURE_MARKER" ]; then
+  msg="$(cat "$FAILURE_MARKER" 2>/dev/null || echo "")"
+  [ -n "$msg" ] || msg="unknown error"
+  echo "openclaw-smart is not installed correctly: $msg" >&2
+  echo "Re-run the plugin's Setup (restart openClaw) or fix the underlying issue and delete $FAILURE_MARKER to retry." >&2
+  exit 1
+fi
+
+if ! command -v uv >/dev/null 2>&1; then
+  # Self-heal: the Setup/SessionStart hook may have been skipped (trust
+  # prompt declined, plugin enabled mid-session, etc.) leaving the install
+  # half-done. Run smart-install.sh inline so the user does not have to
+  # restart openClaw just to recover.
+  # Guard against recursion: if smart-install.sh ever shells back through
+  # this wrapper (e.g. a future migration step) we must not loop forever.
+  if [ "${OPENCLAW_SMART_BOOTSTRAPPING:-}" = "1" ]; then
+    echo "openclaw-smart: bootstrap recursion detected; aborting." >&2
+    exit 1
+  fi
+  if [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
+    echo "openclaw-smart: 'uv' not found — bootstrapping dependencies (~1-3 min on first install)..." >&2
+    # ``set -e`` would short-circuit on a non-zero installer exit and skip
+    # the structured failure-marker checks below. Capture the failure
+    # explicitly so the wrapper continues to the unified error reporting.
+    OPENCLAW_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >&2 || \
+      echo "openclaw-smart: smart-install.sh exited non-zero; continuing to error report" >&2
+    openclaw_smart_prepend_astral_bins
+    openclaw_smart_prepend_node_bins
+  fi
+  if ! command -v uv >/dev/null 2>&1; then
+    if [ -f "$FAILURE_MARKER" ]; then
+      msg="$(cat "$FAILURE_MARKER" 2>/dev/null || echo "unknown error")"
+      echo "openclaw-smart: install failed: $msg" >&2
+      echo "Fix the underlying issue and delete $FAILURE_MARKER to retry." >&2
+    else
+      echo "openclaw-smart: 'uv' not found on PATH after bootstrap attempt." >&2
+      echo "Install it from https://docs.astral.sh/uv/ or rerun $PLUGIN_ROOT/scripts/smart-install.sh manually." >&2
+    fi
+    exit 1
+  fi
+fi
+
+exec uv run --project "$PLUGIN_ROOT" --quiet python -m openclaw_smart.cli "$@"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/dashboard-open.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Open the reflexio dashboard in the user's browser. The dashboard itself
+# (Next.js app) is provided by the claude-smart sibling plugin and listens
+# on http://localhost:3001 by default — both plugins target the same URL.
+# We only need the "open browser" hop here.
+set -eu
+
+URL="${REFLEXIO_DASHBOARD_URL:-http://localhost:3001}"
+if command -v xdg-open >/dev/null 2>&1; then
+  xdg-open "$URL" >/dev/null 2>&1 || true
+elif command -v open >/dev/null 2>&1; then
+  open "$URL" >/dev/null 2>&1 || true
+else
+  echo "Open this URL in your browser: $URL"
+fi

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/ensure-plugin-root.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Maintain ~/.reflexio/openclaw-plugin-root as a symlink to the active plugin
+# install dir so slash commands can reference one short path regardless
+# of whether the user is on the remote marketplace or the local-dev install.
+#
+# Usage: ensure-plugin-root.sh <target-dir> [--force]
+#   --force  overwrite any existing link (used by setup scripts)
+#   default  self-heal only if the link is missing or points at an
+#            invalid target
+set -eu
+
+TARGET="${1:-}"
+FORCE="${2:-}"
+
+if [ -z "$TARGET" ]; then
+    echo "[openclaw-smart] ensure-plugin-root: usage: $0 <target-dir> [--force]" >&2
+    exit 1
+fi
+
+if [ ! -f "$TARGET/pyproject.toml" ]; then
+    echo "[openclaw-smart] ensure-plugin-root: $TARGET is not a plugin dir (no pyproject.toml)" >&2
+    exit 1
+fi
+
+LINK="$HOME/.reflexio/openclaw-plugin-root"
+mkdir -p "$(dirname "$LINK")"
+
+if [ "$FORCE" = "--force" ]; then
+    ln -sfn "$TARGET" "$LINK"
+    echo "[openclaw-smart] plugin-root → $TARGET (forced)" >&2
+    exit 0
+fi
+
+# Opt-in: when OPENCLAW_SMART_PLUGIN_ROOT_FOLLOW_SESSION=1 (set in the
+# environment or in ~/.reflexio/.env), always relink to $TARGET so the
+# symlink tracks the currently loaded plugin. Off by default to preserve
+# a pinned local-dev link across sessions that load the remote plugin.
+FOLLOW="${OPENCLAW_SMART_PLUGIN_ROOT_FOLLOW_SESSION:-}"
+if [ -z "$FOLLOW" ] && [ -f "$HOME/.reflexio/.env" ]; then
+    FOLLOW="$(grep -E '^OPENCLAW_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.reflexio/.env" \
+        | tail -n1 | cut -d= -f2-)"
+    # Strip a single pair of surrounding double or single quotes, if present.
+    FOLLOW="${FOLLOW#\"}"; FOLLOW="${FOLLOW%\"}"
+    FOLLOW="${FOLLOW#\'}"; FOLLOW="${FOLLOW%\'}"
+fi
+if [ "$FOLLOW" = "1" ]; then
+    ln -sfn "$TARGET" "$LINK"
+    echo "[openclaw-smart] plugin-root → $TARGET (follow-session)" >&2
+    exit 0
+fi
+
+# Cache-tracking: if the link currently resolves to a path under the
+# managed openClaw plugin cache (~/.openclaw/plugins/cache/), always
+# retarget it to $TARGET. Plugin updates leave old version directories
+# behind, so a valid pyproject.toml at the stale target is not proof the
+# link is fresh. Links pointing outside the cache (e.g., a user's
+# local-dev checkout) are left alone here and handled by the self-heal
+# below.
+if [ -L "$LINK" ]; then
+    # Literal target string, not realpath: we compare against what was written by ln -s.
+    CURRENT="$(readlink "$LINK" 2>/dev/null || true)"
+    case "$CURRENT" in
+        "$HOME/.openclaw/plugins/cache/"*)
+            CURRENT_NORM="${CURRENT%/}"
+            TARGET_NORM="${TARGET%/}"
+            if [ "$CURRENT_NORM" != "$TARGET_NORM" ]; then
+                ln -sfn "$TARGET" "$LINK"
+                echo "[openclaw-smart] plugin-root → $TARGET (cache-tracking, was $CURRENT)" >&2
+            fi
+            exit 0
+            ;;
+    esac
+fi
+
+# Self-heal path: only rewrite the link if it's missing or its target is
+# gone/invalid. This preserves a valid local-dev symlink set earlier by
+# a setup script, so SessionStart hooks on the local install don't
+# clobber the user's repo-pointing link.
+if [ -f "$LINK/pyproject.toml" ]; then
+    exit 0
+fi
+
+ln -sfn "$TARGET" "$LINK"
+echo "[openclaw-smart] plugin-root → $TARGET" >&2

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/hook_entry.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# Dispatch an openClaw hook event to the openclaw_smart Python package.
+# OPENCLAW_PLUGIN_ROOT points at the plugin dir (dev: <repo>/.../openclaw/plugin;
+# installed: ~/.openclaw/plugins/cache/.../openclaw-smart/<version>),
+# which is also the Python project root with pyproject.toml + uv.lock.
+# We invoke via `uv run --project` so the pinned env from uv.lock is used.
+#
+# If a prior Setup recorded an install failure at
+# ~/.openclaw-smart/install-failed, short-circuit with a user-visible
+# message instead of trying to run uv and failing silently.
+set -eu
+
+HOST="openclaw"
+EVENT="${1:-}"
+case "$EVENT" in
+  openclaw)
+    HOST="$EVENT"
+    EVENT="${2:-}"
+    ;;
+esac
+if [ -z "$EVENT" ]; then
+  echo ''
+  exit 0
+fi
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=_lib.sh
+. "$HERE/_lib.sh"
+if openclaw_smart_is_internal_invocation_env; then
+  echo ''
+  exit 0
+fi
+# Pick up uv from the user's login-shell PATH (covers ~/.local/bin populated
+# by the astral.sh installer) so a fresh install works before the user
+# restarts their terminal. Matches the pattern used by smart-install.sh.
+openclaw_smart_source_login_path
+# Explicit fallback for the astral.sh installer's default paths, in case
+# the user's login-shell rc hasn't yet been re-sourced to pick them up.
+openclaw_smart_prepend_astral_bins
+
+PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
+
+FAILURE_MARKER="$HOME/.openclaw-smart/install-failed"
+STATE_DIR="$HOME/.openclaw-smart"
+if [ -f "$FAILURE_MARKER" ]; then
+  if [ "$EVENT" = "session-start" ] && command -v python3 >/dev/null 2>&1; then
+    python3 - "$FAILURE_MARKER" <<'PY'
+import json, pathlib, sys
+msg = pathlib.Path(sys.argv[1]).read_text().strip() or "unknown error"
+print(json.dumps({
+    "prependContext": (
+        f"> **openclaw-smart is not installed correctly:** {msg}\n"
+        "> Re-run the plugin's Setup (restart openClaw) "
+        "or fix the underlying issue and delete "
+        "`~/.openclaw-smart/install-failed` to retry."
+    )
+}))
+PY
+  else
+    echo ''
+  fi
+  exit 0
+fi
+
+if ! command -v uv >/dev/null 2>&1; then
+  # Self-heal from skipped Setup/SessionStart bootstrap. SessionStart can
+  # afford to wait because it has the install budget; prompt/tool hooks start
+  # the same installer detached so normal work is not blocked by first-run
+  # dependency setup.
+  if [ "${OPENCLAW_SMART_BOOTSTRAPPING:-}" = "1" ]; then
+    echo ''
+    exit 0
+  fi
+  if [ -x "$PLUGIN_ROOT/scripts/smart-install.sh" ]; then
+    mkdir -p "$STATE_DIR"
+    if [ "$EVENT" = "session-start" ]; then
+      OPENCLAW_SMART_BOOTSTRAPPING=1 bash "$PLUGIN_ROOT/scripts/smart-install.sh" >&2
+      openclaw_smart_prepend_astral_bins
+      openclaw_smart_prepend_node_bins
+      if command -v uv >/dev/null 2>&1; then
+        bash "$HERE/backend-service.sh" start >/dev/null 2>&1 || true
+      fi
+    else
+      openclaw_smart_spawn_detached env OPENCLAW_SMART_BOOTSTRAPPING=1 \
+        bash "$PLUGIN_ROOT/scripts/smart-install.sh" \
+        >>"$STATE_DIR/install.log" 2>&1 || true
+    fi
+  fi
+  if ! command -v uv >/dev/null 2>&1; then
+    echo ''
+    exit 0
+  fi
+fi
+
+# Re-check the failure marker after the inline bootstrap. ``smart-install.sh``
+# can write ``install-failed`` *after* uv is on PATH (e.g. ``uv sync`` failed),
+# in which case we still have a working ``uv`` but a non-functional plugin.
+# Without this gate we would proceed to ``uv run`` and crash with a confusing
+# downstream error instead of surfacing the recorded failure reason.
+if [ -f "$FAILURE_MARKER" ]; then
+  echo ''
+  exit 0
+fi
+
+# Stdin is the hook payload JSON — stream it through to the Python CLI.
+exec uv run --project "$PLUGIN_ROOT" --quiet python -m openclaw_smart.hook "$HOST" "$EVENT"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/scripts/npm-cli.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// npm-facing installer for openclaw-smart.
+//
+// This intentionally mirrors the core non-interactive install steps from
+// `reflexio setup openclaw` so npm and Python installs do not drift.
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_ID = "reflexio-openclaw-smart";
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = resolve(SCRIPT_DIR, "..");
+const REFLEXIO_DIR = join(homedir(), ".reflexio");
+const REFLEXIO_ENV = join(REFLEXIO_DIR, ".env");
+const STALE_EXTENSION_DIR = join(homedir(), ".openclaw", "extensions", PLUGIN_ID);
+
+function usage() {
+  console.log(`openclaw-smart
+
+Usage:
+  openclaw-smart install
+  openclaw-smart uninstall [--purge]
+  openclaw-smart repair
+
+Install registers the bundled OpenClaw plugin, enables typed hook access,
+writes OPENCLAW_BIN to ~/.reflexio/.env, warms dependencies, and verifies
+that OpenClaw loaded the plugin.`);
+}
+
+function fail(message, code = 1) {
+  console.error(`openclaw-smart: ${message}`);
+  process.exit(code);
+}
+
+function run(argv, opts = {}) {
+  const result = spawnSync(argv[0], argv.slice(1), {
+    encoding: "utf8",
+    stdio: opts.stdio ?? "pipe",
+    ...opts,
+  });
+  if (result.error) {
+    return {
+      status: 1,
+      stdout: result.stdout ?? "",
+      stderr: result.error.message,
+    };
+  }
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+  };
+}
+
+function findExecutable(name) {
+  const candidates = [];
+  if (process.env.PATH) {
+    for (const dir of process.env.PATH.split(process.platform === "win32" ? ";" : ":")) {
+      if (!dir) continue;
+      candidates.push(join(dir, name));
+      if (process.platform === "win32") candidates.push(join(dir, `${name}.cmd`));
+      if (process.platform === "win32") candidates.push(join(dir, `${name}.exe`));
+    }
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function resolveOpenClawBin() {
+  // Absolutize the result: this value is written to ~/.reflexio/.env and later
+  // read by backend subprocesses that may run from a different cwd, so a
+  // relative OPENCLAW_BIN or relative PATH entry must not leak through.
+  const configured = process.env.OPENCLAW_BIN;
+  if (configured && existsSync(configured)) return resolve(configured);
+  const found = findExecutable("openclaw");
+  return found ? resolve(found) : found;
+}
+
+function shellQuote(value) {
+  return `"${String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function upsertEnv(envPath, updates) {
+  mkdirSync(dirname(envPath), { recursive: true });
+  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8").split(/\r?\n/) : [];
+  const remaining = existing.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return true;
+    return !Object.keys(updates).some((key) => trimmed.startsWith(`${key}=`));
+  });
+  for (const [key, value] of Object.entries(updates)) {
+    remaining.push(`${key}=${shellQuote(value)}`);
+  }
+  writeFileSync(envPath, `${remaining.filter((line) => line.length > 0).join("\n")}\n`);
+}
+
+function removeEnvKeys(envPath, keys) {
+  if (!existsSync(envPath)) return;
+  const kept = readFileSync(envPath, "utf8")
+    .split(/\r?\n/)
+    .filter((line) => !keys.some((key) => line.trim().startsWith(`${key}=`)))
+    .filter((line) => line.length > 0);
+  writeFileSync(envPath, kept.length ? `${kept.join("\n")}\n` : "");
+}
+
+function ensurePluginRoot() {
+  if (!existsSync(join(PLUGIN_ROOT, "openclaw.plugin.json"))) {
+    fail(`plugin root is incomplete: ${PLUGIN_ROOT}`);
+  }
+}
+
+function runOpenClaw(cli, args, opts = {}) {
+  return run([cli, ...args], opts);
+}
+
+function printCommandFailure(label, result) {
+  const detail = (result.stderr || result.stdout || "").trim();
+  console.error(`openclaw-smart: ${label} failed${detail ? `: ${detail}` : ""}`);
+}
+
+function runSmartInstall() {
+  const script = join(PLUGIN_ROOT, "scripts", "smart-install.sh");
+  if (!existsSync(script)) {
+    console.warn(`openclaw-smart: ${script} missing; skipping dependency warmup`);
+    return;
+  }
+  const result = run(["bash", script], { stdio: "inherit" });
+  if (result.status !== 0) {
+    console.warn(
+      `openclaw-smart: smart-install.sh exited ${result.status}; first session may bootstrap dependencies`,
+    );
+  }
+}
+
+function inspectLoaded(cli) {
+  const result = runOpenClaw(cli, ["plugins", "inspect", PLUGIN_ID]);
+  return result.status === 0 && /Status:\s*loaded\b/.test(result.stdout);
+}
+
+function install() {
+  ensurePluginRoot();
+  const cli = resolveOpenClawBin();
+  if (!cli) fail("openclaw CLI not found. Install OpenClaw first or set OPENCLAW_BIN.");
+
+  upsertEnv(REFLEXIO_ENV, {
+    OPENCLAW_BIN: cli,
+    OPENCLAW_SMART_USE_LOCAL_CLI: "1",
+  });
+
+  runOpenClaw(cli, ["plugins", "uninstall", "--force", PLUGIN_ID]);
+  rmSync(STALE_EXTENSION_DIR, { recursive: true, force: true });
+
+  const installResult = runOpenClaw(cli, ["plugins", "install", PLUGIN_ROOT]);
+  if (installResult.status !== 0) {
+    printCommandFailure("plugins install", installResult);
+    process.exit(1);
+  }
+
+  const enableResult = runOpenClaw(cli, ["plugins", "enable", PLUGIN_ID]);
+  if (enableResult.status !== 0) {
+    printCommandFailure("plugins enable", enableResult);
+    process.exit(1);
+  }
+
+  const accessResult = runOpenClaw(cli, [
+    "config",
+    "set",
+    `plugins.entries.${PLUGIN_ID}.hooks.allowConversationAccess`,
+    "true",
+  ]);
+  if (accessResult.status !== 0) {
+    printCommandFailure("config set allowConversationAccess", accessResult);
+    process.exit(1);
+  }
+
+  runSmartInstall();
+  runOpenClaw(cli, ["gateway", "restart"]);
+
+  if (!inspectLoaded(cli)) {
+    fail(`plugin not loaded; check 'openclaw plugins inspect ${PLUGIN_ID}'`);
+  }
+  console.log("openclaw-smart installed and registered.");
+}
+
+function uninstall({ purge = false } = {}) {
+  const cli = resolveOpenClawBin();
+  if (cli) {
+    runOpenClaw(cli, ["plugins", "disable", PLUGIN_ID]);
+    runOpenClaw(cli, ["plugins", "uninstall", "--force", PLUGIN_ID]);
+  } else {
+    console.warn("openclaw-smart: openclaw CLI not found; skipping plugin removal");
+  }
+  removeEnvKeys(REFLEXIO_ENV, ["OPENCLAW_BIN", "OPENCLAW_SMART_USE_LOCAL_CLI"]);
+  if (purge) rmSync(join(homedir(), ".openclaw-smart"), { recursive: true, force: true });
+  console.log("openclaw-smart uninstalled.");
+}
+
+function repair() {
+  runSmartInstall();
+  console.log("openclaw-smart repair complete.");
+}
+
+const [command, ...args] = process.argv.slice(2);
+if (!command || command === "-h" || command === "--help") {
+  usage();
+  process.exit(0);
+}
+if (command === "install") install();
+else if (command === "uninstall") uninstall({ purge: args.includes("--purge") });
+else if (command === "repair") repair();
+else {
+  usage();
+  fail(`unknown command: ${command}`);
+}