grix-connector 1.0.2

package/openclaw-plugin/skills/openclaw-memory-setup/scripts/survey_host_readiness.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * Survey host readiness for Ollama and OpenClaw memory setup.
+ *
+ * Emits a readable report by default, or JSON with --json.
+ */
+
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+
+type Report = {
+  os: string;
+  release: string;
+  arch: string;
+  shell_context: string;
+  cpu_count: number;
+  memory_gib: number | null;
+  commands: Record<string, string | null>;
+  versions: Record<string, string | null>;
+  ollama_api: { reachable: boolean; models: string[] };
+  recommended_candidates: string[];
+  openclaw_install_note: string;
+};
+
+function usageText(): string {
+  return [
+    "Usage:",
+    "  node scripts/survey_host_readiness.ts [--ollama-host <url>] [--json]",
+    "",
+    "Options:",
+    "  --ollama-host <url>   Ollama host to probe (default http://127.0.0.1:11434)",
+    "  --json               Emit JSON instead of a readable report",
+  ].join("\n");
+}
+
+function systemName(): string {
+  if (process.platform === "win32") return "Windows";
+  if (process.platform === "darwin") return "Darwin";
+  if (process.platform === "linux") return "Linux";
+  return process.platform;
+}
+
+function shellContext(): string {
+  if (process.platform === "win32") return "windows-native";
+  if (process.platform === "darwin") return "macos-native";
+  if (process.platform === "linux") {
+    const lowerRelease = os.release().toLowerCase();
+    if (lowerRelease.includes("microsoft") || lowerRelease.includes("wsl")) {
+      return "wsl";
+    }
+    try {
+      const version = readFileSync("/proc/version", "utf8").toLowerCase();
+      if (version.includes("microsoft")) {
+        return "wsl";
+      }
+    } catch {
+      // ignore
+    }
+    return "linux-native";
+  }
+  return "unknown";
+}
+
+function isExecutableFile(path: string): boolean {
+  try {
+    const stats = statSync(path);
+    if (!stats.isFile()) return false;
+    if (process.platform === "win32") return true;
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function commandCandidates(command: string): string[] {
+  const normalized = command.trim();
+  if (!normalized) return [];
+
+  const candidates: string[] = [];
+  const unixBins = ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin"];
+
+  if (normalized === "node") {
+    candidates.push(process.execPath);
+  }
+
+  if (normalized === "npm") {
+    const base = dirname(process.execPath);
+    if (process.platform === "win32") {
+      candidates.push(join(base, "npm.cmd"), join(base, "npm.exe"));
+    } else {
+      candidates.push(join(base, "npm"));
+    }
+  }
+
+  if (process.platform === "win32") {
+    if (normalized === "ollama") {
+      candidates.push(
+        "C:\\\\Program Files\\\\Ollama\\\\ollama.exe",
+        "C:\\\\Program Files (x86)\\\\Ollama\\\\ollama.exe",
+      );
+    }
+    if (normalized === "node") {
+      candidates.push("C:\\\\Program Files\\\\nodejs\\\\node.exe", "C:\\\\Program Files (x86)\\\\nodejs\\\\node.exe");
+    }
+    if (normalized === "npm") {
+      candidates.push("C:\\\\Program Files\\\\nodejs\\\\npm.cmd", "C:\\\\Program Files (x86)\\\\nodejs\\\\npm.cmd");
+    }
+    if (normalized === "openclaw") {
+      candidates.push("C:\\\\Program Files\\\\OpenClaw\\\\openclaw.exe", "C:\\\\Program Files (x86)\\\\OpenClaw\\\\openclaw.exe");
+    }
+    return candidates;
+  }
+
+  for (const dir of unixBins) {
+    candidates.push(join(dir, normalized));
+  }
+  return candidates;
+}
+
+function resolveCommandPath(command: string): string | null {
+  for (const candidate of commandCandidates(command)) {
+    if (isExecutableFile(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function commandVersion(command: string, path: string | null): string | null {
+  if (!path) return null;
+  if (command === "node") {
+    return process.version;
+  }
+  return null;
+}
+
+function recommendCandidates(memoryGib: number | null): string[] {
+  if (memoryGib === null) {
+    return ["embeddinggemma:300m-qat-q8_0", "nomic-embed-text:latest", "qwen3-embedding:0.6b"];
+  }
+  if (memoryGib < 8) {
+    return ["nomic-embed-text:latest", "embeddinggemma:300m-qat-q8_0"];
+  }
+  if (memoryGib < 32) {
+    return ["embeddinggemma:300m-qat-q8_0", "nomic-embed-text:latest", "qwen3-embedding:0.6b"];
+  }
+  return [
+    "embeddinggemma:300m-qat-q8_0",
+    "nomic-embed-text:latest",
+    "qwen3-embedding:0.6b",
+    "qwen3-embedding:latest",
+  ];
+}
+
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function probeOllama(host: string): Promise<{ reachable: boolean; models: string[] }> {
+  const url = host.replace(/\/+$/, "") + "/api/tags";
+  try {
+    const response = await fetchWithTimeout(url, 5000);
+    if (!response.ok) {
+      return { reachable: false, models: [] };
+    }
+    const text = await response.text();
+    const payload = JSON.parse(text) as { models?: unknown };
+    const models = Array.isArray(payload.models) ? payload.models : [];
+    const names = models
+      .map((item) => (item && typeof item === "object" ? (item as Record<string, unknown>).name : undefined))
+      .filter((name): name is string => typeof name === "string");
+    return { reachable: true, models: names };
+  } catch {
+    return { reachable: false, models: [] };
+  }
+}
+
+async function buildReport(ollamaHost: string): Promise<Report> {
+  const memoryGib = os.totalmem() ? os.totalmem() / 1024 / 1024 / 1024 : null;
+  const commands: Record<string, string | null> = {};
+  const versions: Record<string, string | null> = {};
+
+  for (const command of ["ollama", "openclaw", "node", "npm"]) {
+    const path = resolveCommandPath(command);
+    commands[command] = path;
+    versions[command] = commandVersion(command, path);
+  }
+
+  commands.openclaw_management = commands.openclaw;
+  versions.openclaw_management = versions.openclaw;
+
+  const ollamaApi = await probeOllama(ollamaHost);
+  const osName = systemName();
+
+  return {
+    os: osName,
+    release: os.release(),
+    arch: os.arch(),
+    shell_context: shellContext(),
+    cpu_count: os.cpus().length,
+    memory_gib: memoryGib === null ? null : Math.round(memoryGib * 100) / 100,
+    commands,
+    versions,
+    ollama_api: ollamaApi,
+    recommended_candidates: recommendCandidates(memoryGib === null ? null : memoryGib),
+    openclaw_install_note:
+      osName === "Windows"
+        ? "Use Mac or Linux directly; use WSL on Windows for current official OpenClaw setup."
+        : "Use the official Ollama OpenClaw launch flow.",
+  };
+}
+
+function printText(report: Report, ollamaHost: string): void {
+  process.stdout.write("System\n");
+  process.stdout.write(`  OS: ${report.os} ${report.release}\n`);
+  process.stdout.write(`  Context: ${report.shell_context}\n`);
+  process.stdout.write(`  Arch: ${report.arch}\n`);
+  process.stdout.write(`  CPUs: ${report.cpu_count}\n`);
+  process.stdout.write(`  RAM GiB: ${report.memory_gib ?? "unknown"}\n\n`);
+
+  process.stdout.write("Commands\n");
+  for (const [command, path] of Object.entries(report.commands)) {
+    const version = report.versions[command] ?? null;
+    const label = command === "openclaw_management" ? "openclaw management" : command;
+    if (path) {
+      const suffix = version ? ` (${version})` : "";
+      process.stdout.write(`  ${label}: ${path}${suffix}\n`);
+    } else {
+      process.stdout.write(`  ${label}: missing\n`);
+    }
+  }
+
+  process.stdout.write("\nOllama API\n");
+  if (report.ollama_api.reachable) {
+    process.stdout.write(`  ${ollamaHost}: reachable\n`);
+    process.stdout.write(
+      `  Models: ${report.ollama_api.models.length ? report.ollama_api.models.join(", ") : "none pulled"}\n`,
+    );
+  } else {
+    process.stdout.write(`  ${ollamaHost}: unreachable\n`);
+  }
+
+  process.stdout.write("\nRecommended candidates\n");
+  for (const model of report.recommended_candidates) {
+    process.stdout.write(`  - ${model}\n`);
+  }
+  process.stdout.write(`\nOpenClaw install note\n  ${report.openclaw_install_note}\n`);
+}
+
+async function main(): Promise<number> {
+  const parsed = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      "ollama-host": { type: "string", default: "http://127.0.0.1:11434" },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+    },
+  });
+
+  if (parsed.values.help) {
+    process.stdout.write(`${usageText()}\n`);
+    return 0;
+  }
+
+  const ollamaHost = String(parsed.values["ollama-host"] ?? "").trim() || "http://127.0.0.1:11434";
+  const report = await buildReport(ollamaHost);
+
+  if (parsed.values.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } else {
+    printText(report, ollamaHost);
+  }
+
+  return 0;
+}
+
+void main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+  });

package/openclaw.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "grix",
+  "version": "0.5.2",
+  "skills": [
+    "./openclaw-plugin/skills"
+  ],
+  "channels": [
+    "grix"
+  ],
+  "channelConfigs": {
+    "grix": {
+      "schema": {
+        "type": "object",
+        "additionalProperties": true
+      },
+      "label": "Grix"
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "grix-connector",
+  "version": "1.0.2",
+  "description": "Connect local AI coding agents (Claude, Codex, Gemini, Qwen, DeepSeek, Cursor, OpenCode, Pi, OpenHuman, Reasonix) to the Grix scheduling platform. Also serves as an OpenClaw plugin for Grix channel transport.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "grix-connector": "dist/grix.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.d.ts",
+    "openclaw-plugin",
+    "scripts/install-guardian.mjs",
+    "scripts/install-guardian.sh",
+    "scripts/upgrade-guardian.sh",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/install-guardian.mjs",
+    "prepublishOnly": "npm run build:all",
+    "build": "tsc",
+    "build:plugin": "node scripts/build-plugin.mjs",
+    "build:all": "npm run build && node scripts/minify-dist.mjs && npm run build:plugin",
+    "dev": "npm run build && node dist/grix.js",
+    "test": "node --experimental-vm-modules node_modules/vitest/vitest.mjs run",
+    "test:watch": "node --experimental-vm-modules node_modules/vitest/vitest.mjs",
+    "lint": "tsc --noEmit",
+    "start": "node dist/grix.js start",
+    "stop": "node dist/grix.js stop",
+    "restart": "node dist/grix.js restart",
+    "status": "node dist/grix.js status"
+  },
+  "keywords": [
+    "grix",
+    "aibot",
+    "agent-connector",
+    "claude",
+    "codex",
+    "gemini",
+    "qwen",
+    "deepseek",
+    "cursor",
+    "opencode",
+    "pi",
+    "openhuman",
+    "reasonix",
+    "acp",
+    "agent-client-protocol",
+    "mcp",
+    "openclaw",
+    "openclaw-plugin"
+  ],
+  "author": "askie",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/askie/grix-connector.git"
+  },
+  "homepage": "https://github.com/askie/grix-connector#readme",
+  "bugs": {
+    "url": "https://github.com/askie/grix-connector/issues"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@types/ws": "^8.18.1",
+    "esbuild": "^0.27.7",
+    "fast-check": "^4.8.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.4.8"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "extract-zip": "^2.0.1",
+    "socket.io-client": "^4.8.3",
+    "ws": "^8.20.0"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./openclaw-plugin/index.js"
+    ],
+    "channel": {
+      "id": "grix",
+      "label": "Grix",
+      "selectionLabel": "Grix",
+      "docsPath": "/channels/grix",
+      "blurb": "Connect OpenClaw to a Grix deployment for website management with mobile PWA support.",
+      "aliases": [
+        "gr"
+      ],
+      "order": 90
+    },
+    "install": {
+      "npmSpec": "grix-connector",
+      "localPath": ".",
+      "defaultChoice": "npm"
+    }
+  }
+}

package/scripts/install-guardian.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// install-guardian — cross-platform npm postinstall script
+// Copies upgrade-guardian.sh to ~/.grix/bin/ (idempotent, won't overwrite existing)
+// On Windows, skips since the guardian is a bash script.
+
+import { existsSync, copyFileSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+// Guardian is a bash script — skip on Windows entirely
+if (process.platform === 'win32') {
+  process.exit(0);
+}
+
+const GRIX_HOME = process.env.GRIX_CONNECTOR_HOME || join(homedir(), '.grix');
+const GUARDIAN_DEST = join(GRIX_HOME, 'bin', 'upgrade-guardian.sh');
+
+if (existsSync(GUARDIAN_DEST)) {
+  process.exit(0);
+}
+
+const INIT_CWD = process.env.INIT_CWD || resolve(import.meta.dirname);
+const GUARDIAN_SRC = join(INIT_CWD, 'scripts', 'upgrade-guardian.sh');
+
+if (!existsSync(GUARDIAN_SRC)) {
+  process.exit(0);
+}
+
+mkdirSync(join(GRIX_HOME, 'bin'), { recursive: true });
+copyFileSync(GUARDIAN_SRC, GUARDIAN_DEST);

package/scripts/install-guardian.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# install-guardian.sh — npm postinstall script
+# Copies upgrade-guardian.sh to ~/.grix/bin/ (idempotent, won't overwrite existing)
+# This ensures the guardian script exists on first install and survives npm upgrades.
+
+set -e
+
+GRIX_HOME="${GRIX_CONNECTOR_HOME:-$HOME/.grix}"
+GUARDIAN_DEST="$GRIX_HOME/bin/upgrade-guardian.sh"
+
+# Don't overwrite — user may have custom modifications
+if [ -f "$GUARDIAN_DEST" ]; then
+  exit 0
+fi
+
+# Locate source: INIT_CWD is set by npm to the package root during lifecycle scripts
+GUARDIAN_SRC="${INIT_CWD:-$(dirname "$0")}/scripts/upgrade-guardian.sh"
+if [ ! -f "$GUARDIAN_SRC" ]; then
+  # Fallback: try relative to this script
+  GUARDIAN_SRC="$(cd "$(dirname "$0")" && pwd)/upgrade-guardian.sh"
+fi
+
+if [ ! -f "$GUARDIAN_SRC" ]; then
+  echo "grix-connector postinstall: guardian source not found, skipping" >&2
+  exit 0
+fi
+
+mkdir -p "$GRIX_HOME/bin"
+cp "$GUARDIAN_SRC" "$GUARDIAN_DEST"
+chmod +x "$GUARDIAN_DEST"

package/scripts/upgrade-guardian.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# upgrade-guardian.sh — post-upgrade health monitor
+# Started by daemon after npm install, runs as detached background process.
+# Monitors healthz for 90s, rolls back on crash_count >= 3.
+# This file is NOT inside the npm package — installed once to ~/.grix/bin/.
+
+GRIX_HOME="${GRIX_CONNECTOR_HOME:-$HOME/.grix}"
+PENDING_FILE="$GRIX_HOME/data/upgrade-pending.json"
+LOCK_FILE="$GRIX_HOME/upgrade-guardian.lock"
+LOG_FILE="$GRIX_HOME/log/upgrade.log"
+MAX_CRASHES=3
+HEALTH_TIMEOUT=90
+HEALTH_PORT_FILE="$GRIX_HOME/data/health-port"
+HEALTH_PORT=$(cat "$HEALTH_PORT_FILE" 2>/dev/null || echo "19579")
+HEALTH_URL="http://127.0.0.1:${HEALTH_PORT}/healthz"
+NPM_PACKAGE="grix-connector"
+
+# Ensure directories exist
+mkdir -p "$GRIX_HOME/log" "$GRIX_HOME/data"
+
+log() {
+    echo "[$(date '+%Y-%m-%dT%H:%M:%S%z')] guardian: $1" >> "$LOG_FILE"
+}
+
+# Prevent duplicate guardian instances
+if [ -f "$LOCK_FILE" ]; then
+    LOCK_PID=$(cat "$LOCK_FILE" 2>/dev/null)
+    if [ -n "$LOCK_PID" ] && kill -0 "$LOCK_PID" 2>/dev/null; then
+        exit 0
+    fi
+    rm -f "$LOCK_FILE"
+fi
+echo $$ > "$LOCK_FILE"
+trap 'rm -f "$LOCK_FILE"' EXIT
+
+# Read pending marker
+if [ ! -f "$PENDING_FILE" ]; then
+    exit 0
+fi
+
+# Extract fields from JSON (portable: no jq dependency)
+FROM_VERSION=$(cat "$PENDING_FILE" | grep -o '"from_version":"[^"]*"' | cut -d'"' -f4)
+TARGET_VERSION=$(cat "$PENDING_FILE" | grep -o '"target_version":"[^"]*"' | cut -d'"' -f4)
+UPGRADED_AT=$(cat "$PENDING_FILE" | grep -o '"upgraded_at":"[^"]*"' | cut -d'"' -f4)
+CRASH_COUNT=$(cat "$PENDING_FILE" | grep -o '"crash_count":[0-9]*' | cut -d: -f2)
+CRASH_COUNT=${CRASH_COUNT:-0}
+
+# Validate pending file
+if [ -z "$FROM_VERSION" ]; then
+    log "pending file corrupt, missing from_version, removing"
+    rm -f "$PENDING_FILE"
+    exit 0
+fi
+
+log "started: from=$FROM_VERSION target=$TARGET_VERSION crash_count=$CRASH_COUNT"
+
+# Wait for old daemon to exit (SIGTERM + shutdown + restart)
+sleep 15
+
+# Monitor loop: wait for healthz to return 200
+ELAPSED=0
+while [ $ELAPSED -lt $HEALTH_TIMEOUT ]; do
+    if curl -sf "$HEALTH_URL" > /dev/null 2>&1; then
+        log "healthz passed, upgrade successful"
+        rm -f "$PENDING_FILE"
+        exit 0
+    fi
+    sleep 3
+    ELAPSED=$((ELAPSED + 3))
+done
+
+# Extra grace period for slow systems
+sleep 15
+if curl -sf "$HEALTH_URL" > /dev/null 2>&1; then
+    log "healthz passed (delayed), upgrade successful"
+    rm -f "$PENDING_FILE"
+    exit 0
+fi
+
+# Health check failed
+CRASH_COUNT=$((CRASH_COUNT + 1))
+log "healthz timeout, crash_count=$CRASH_COUNT"
+
+if [ $CRASH_COUNT -ge $MAX_CRASHES ]; then
+    log "rollback: installing ${NPM_PACKAGE}@${FROM_VERSION}"
+    if npm install -g "${NPM_PACKAGE}@${FROM_VERSION}" --prefer-online --no-audit --no-fund >> "$LOG_FILE" 2>&1; then
+        log "rollback succeeded"
+        rm -f "$PENDING_FILE"
+    else
+        log "ROLLBACK FAILED — manual intervention required"
+    fi
+    exit 0
+fi
+
+# Under threshold — update crash_count and exit, let process manager restart
+echo "{\"from_version\":\"$FROM_VERSION\",\"target_version\":\"$TARGET_VERSION\",\"upgraded_at\":\"$UPGRADED_AT\",\"crash_count\":$CRASH_COUNT}" > "$PENDING_FILE.tmp"
+mv "$PENDING_FILE.tmp" "$PENDING_FILE"
+log "updated crash_count to $CRASH_COUNT, exiting"