squish-memory 1.1.5 → 1.2.1

package/scripts/squish-fallback.mjs

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-const root = process.cwd();
-const policyPath = path.join(root, "config", "mcp-cli-fallback-policy.json");
-
-function parseArgs(argv) {
-  const args = {
-    op: "",
-    payload: "",
-    dryRun: false,
-    simulateMcpFailure: false,
-    mcpEnabled: process.env.SQUISH_MCP_ENABLED === "true"
-  };
-
-  for (let i = 2; i < argv.length; i += 1) {
-    const token = argv[i];
-    if (token === "--op") {
-      args.op = argv[i + 1] || "";
-      i += 1;
-      continue;
-    }
-    if (token === "--payload") {
-      args.payload = argv[i + 1] || "";
-      i += 1;
-      continue;
-    }
-    if (token === "--dry-run") {
-      args.dryRun = true;
-      continue;
-    }
-    if (token === "--simulate-mcp-failure") {
-      args.simulateMcpFailure = true;
-      continue;
-    }
-    if (token === "--mcp-enabled") {
-      args.mcpEnabled = true;
-      continue;
-    }
-    if (token === "--no-mcp") {
-      args.mcpEnabled = false;
-      continue;
-    }
-    throw new Error(`Unknown argument: ${token}`);
-  }
-
-  if (!args.op) {
-    throw new Error("Missing required argument: --op");
-  }
-  return args;
-}
-
-function readPolicy() {
-  return JSON.parse(fs.readFileSync(policyPath, "utf8"));
-}
-
-function assertAllowed(policy, op, payload) {
-  if (!policy.allowOperations.includes(op)) {
-    throw new Error(`Operation not allowed by fallback policy: ${op}`);
-  }
-  for (const pattern of policy.denyPatterns) {
-    const rx = new RegExp(pattern, "i");
-    if (rx.test(payload)) {
-      throw new Error(`Payload blocked by fallback deny pattern: ${pattern}`);
-    }
-  }
-}
-
-function output(result) {
-  process.stdout.write(`${JSON.stringify(result)}\n`);
-}
-
-function runCliFallback(op, payload, dryRun) {
-  if (dryRun) {
-    return { success: true, executionPath: "cli-fallback", op, dryRun };
-  }
-
-  const args = [op];
-  if (payload && payload.trim().length > 0) {
-    args.push(payload);
-  }
-
-  const run = spawnSync("squish", args, { encoding: "utf8" });
-  if (run.status !== 0) {
-    return {
-      success: false,
-      executionPath: "cli-fallback",
-      op,
-      error: run.stderr || run.stdout || "squish command failed"
-    };
-  }
-
-  return {
-    success: true,
-    executionPath: "cli-fallback",
-    op,
-    output: run.stdout.trim()
-  };
-}
-
-function runMcp(op, dryRun) {
-  if (dryRun) {
-    return { success: true, executionPath: "mcp", op, dryRun };
-  }
-
-  return {
-    success: true,
-    executionPath: "mcp",
-    op,
-    output: "MCP call path selected"
-  };
-}
-
-function main() {
-  const args = parseArgs(process.argv);
-  const policy = readPolicy();
-
-  assertAllowed(policy, args.op, args.payload);
-
-  const shouldFallback = !args.mcpEnabled || args.simulateMcpFailure;
-  const result = shouldFallback
-    ? runCliFallback(args.op, args.payload, args.dryRun)
-    : runMcp(args.op, args.dryRun);
-
-  output(result);
-  process.exit(result.success ? 0 : 1);
-}
-
-main();

package/scripts/test-interactive.mjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-import path from "node:path";
-
-const colors = {
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  cyan: "\x1b[36m",
-  red: "\x1b[31m",
-  reset: "\x1b[0m",
-  gray: "\x1b[90m"
-};
-
-const root = process.cwd();
-const testScriptPath = path.join(root, "scripts", "install-interactive.mjs");
-
-let testsRun = 0;
-let testsPassed = 0;
-let testsFailed = 0;
-
-function logTest(testName) {
-  testsRun++;
-  console.log(`\n${colors.cyan}TEST ${testsRun}:${colors.reset} ${testName}`);
-}
-
-function logPass(message) {
-  testsPassed++;
-  console.log(`  ${colors.green}✓${colors.reset} ${message}`);
-}
-
-function logFail(message, error) {
-  testsFailed++;
-  console.log(`  ${colors.red}✗${colors.reset} ${message}`);
-  if (error) {
-    console.log(`    ${colors.gray}${error}${colors.reset}`);
-  }
-}
-
-function logSkip(message) {
-  console.log(`  ${colors.yellow}○${colors.reset} ${message}`);
-}
-
-function runTest(description, args, envVars = {}, expectedExitCode = 0) {
-  logTest(description);
-  
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [testScriptPath, ...args], {
-      stdio: ["inherit", "pipe", "pipe"],
-      timeout: 5000,
-      env: { ...process.env, ...envVars }
-    });
-    
-    let stdout = "";
-    let stderr = "";
-    
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    
-    child.on("close", (code) => {
-      if (code === expectedExitCode) {
-        logPass(`Exit code: ${code}`);
-      } else {
-        logFail(`Expected exit code ${expectedExitCode}, got ${code}`, stderr);
-      }
-      resolve({ code, stdout, stderr });
-    });
-    
-    child.on("error", (err) => {
-      logFail("Spawn failed", err.message);
-      resolve({ code: -1, stderr: err.message });
-    });
-  });
-}
-
-async function runTests() {
-  console.log(`${colors.cyan}═════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.cyan}Interactive Installer Test Suite${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════${colors.reset}`);
-  console.log("");
-  
-  await runTest("Syntax check (no syntax errors)", ["--help"]);
-  
-  await runTest("Help flag displays usage", ["--help"]);
-  
-  await runTest("List flag shows available plugins", ["--list"]);
-  
-  await runTest("Auto mode with --all flag", ["--all", "--dry-run"]);
-  
-  await runTest("Auto mode with --select flag", ["--select=claude-code", "--dry-run"]);
-  
-  await runTest("Environment detection - CI mode", ["--list"], { CI: "true" });
-  
-  await runTest("Environment detection - NON_INTERACTIVE mode", ["--list"], { NON_INTERACTIVE: "1" });
-  
-  await runTest("Dry-run preview mode", ["--list", "--dry-run"]);
-  
-  await runTest("Multiple flag combination", ["--select=claude-code,openclaw", "--verbose", "--dry-run"]);
-  
-  await runTest("Invalid flag handling", ["--invalid-flag"], {}, 1);
-  
-  await runTest("Invalid plugin in --select", ["--select=nonexistent"], {}, 1);
-  
-  console.log("");
-  console.log(`${colors.cyan}═════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.cyan}Test Summary${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════${colors.reset}`);
-  console.log("");
-  console.log(`  ${colors.gray}Total tests:${colors.reset} ${testsRun}`);
-  console.log(`  ${colors.green}Passed:${colors.reset} ${testsPassed}`);
-  console.log(`  ${colors.red}Failed:${colors.reset} ${testsFailed}`);
-  console.log("");
-  
-  if (testsFailed === 0) {
-    console.log(`${colors.green}All tests passed!${colors.reset}`);
-  } else {
-    console.log(`${colors.yellow}${testsFailed} test(s) failed${colors.reset}`);
-  }
-}
-
-runTests().then(() => {
-  process.exit(testsFailed > 0 ? 1 : 0);
-}).catch((err) => {
-  console.log(`${colors.red}Fatal test error:${colors.reset} ${err.message}`);
-  process.exit(1);
-});

package/scripts/verify-mcp.mjs

@@ -1,214 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import { spawnSync } from "node:child_process";
-
-const root = process.cwd();
-const defaultConfigPath = path.join(root, "config", "mcp.json");
-const defaultGeneratedDir = path.join(root, "generated", "mcp");
-const requiredFiles = [
-  "runtime.json",
-  "mcp-servers.json",
-  "mcporter.json",
-  "openclaw-memory-qmd.json",
-  "manifest.json"
-];
-
-function parseArgs(argv) {
-  const args = {
-    configPath: defaultConfigPath,
-    generatedDir: defaultGeneratedDir,
-    checkReproducibility: true
-  };
-
-  for (let i = 2; i < argv.length; i += 1) {
-    const token = argv[i];
-    if (token === "--config") {
-      args.configPath = path.resolve(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    if (token === "--generated") {
-      args.generatedDir = path.resolve(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    if (token === "--no-repro") {
-      args.checkReproducibility = false;
-      continue;
-    }
-    throw new Error(`Unknown argument: ${token}`);
-  }
-
-  return args;
-}
-
-function fail(message) {
-  throw new Error(message);
-}
-
-function readJson(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-  } catch (error) {
-    fail(`Invalid JSON at ${filePath}: ${String(error)}`);
-  }
-}
-
-function checksum(filePath) {
-  const hash = crypto.createHash("sha256");
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest("hex");
-}
-
-function assertServerShape(serverName, server) {
-  if (!server || typeof server !== "object") {
-    fail(`Server ${serverName} must be an object`);
-  }
-  if (typeof server.command !== "string" || server.command.length === 0) {
-    fail(`Server ${serverName} must include command`);
-  }
-  if (!Array.isArray(server.args)) {
-    fail(`Server ${serverName} must include args array`);
-  }
-  if (typeof server.transport !== "string" || server.transport.length === 0) {
-    fail(`Server ${serverName} must include transport`);
-  }
-  if (!server.env || typeof server.env !== "object") {
-    fail(`Server ${serverName} must include env object`);
-  }
-}
-
-function verifyGeneratedFiles(dirPath) {
-  for (const fileName of requiredFiles) {
-    const filePath = path.join(dirPath, fileName);
-    if (!fs.existsSync(filePath)) {
-      fail(`Missing generated file: ${fileName}`);
-    }
-  }
-}
-
-function verifyRuntime(runtime) {
-  const requiredKeys = [
-    "connectionTimeoutMs",
-    "requestTimeoutMs",
-    "maxConcurrentToolCalls",
-    "lazyToolDiscovery",
-    "resultMaxChars",
-    "retry"
-  ];
-  for (const key of requiredKeys) {
-    if (!(key in runtime)) {
-      fail(`runtime.json missing required key: ${key}`);
-    }
-  }
-}
-
-function verifyManifest(manifest, dirPath) {
-  if (manifest.mode !== "universal") {
-    fail("manifest mode must be universal");
-  }
-  if (!Array.isArray(manifest.files) || manifest.files.length === 0) {
-    fail("manifest files must be a non-empty array");
-  }
-
-  const expectedManifestEntries = [
-    "runtime.json",
-    "mcp-servers.json",
-    "mcporter.json",
-    "openclaw-memory-qmd.json"
-  ];
-
-  for (const fileName of expectedManifestEntries) {
-    const entry = manifest.files.find((item) => item.file === fileName);
-    if (!entry) {
-      fail(`manifest missing entry for ${fileName}`);
-    }
-    const actualHash = checksum(path.join(dirPath, fileName));
-    if (entry.sha256 !== actualHash) {
-      fail(`manifest checksum mismatch for ${fileName}`);
-    }
-  }
-}
-
-function verifyReproducibility(configPath, dirPath) {
-  const first = readJson(path.join(dirPath, "manifest.json"));
-  const firstChecksums = new Map(first.files.map((item) => [item.file, item.sha256]));
-
-  const run = spawnSync(
-    process.execPath,
-    ["scripts/generate-mcp.mjs", "--config", configPath, "--out", dirPath],
-    { cwd: root, encoding: "utf8" }
-  );
-
-  if (run.status !== 0) {
-    fail(`Reproducibility generation failed: ${run.stderr || run.stdout}`);
-  }
-
-  const second = readJson(path.join(dirPath, "manifest.json"));
-  const secondChecksums = new Map(second.files.map((item) => [item.file, item.sha256]));
-
-  for (const [fileName, firstHash] of firstChecksums.entries()) {
-    const secondHash = secondChecksums.get(fileName);
-    if (!secondHash) {
-      fail(`Reproducibility check missing ${fileName} in second manifest`);
-    }
-    if (firstHash !== secondHash) {
-      fail(`Reproducibility mismatch for ${fileName}`);
-    }
-  }
-}
-
-function main() {
-  const args = parseArgs(process.argv);
-
-  if (!fs.existsSync(args.configPath)) {
-    fail(`Config file not found: ${args.configPath}`);
-  }
-  if (!fs.existsSync(args.generatedDir)) {
-    fail(`Generated directory not found: ${args.generatedDir}`);
-  }
-
-  verifyGeneratedFiles(args.generatedDir);
-
-  const runtime = readJson(path.join(args.generatedDir, "runtime.json"));
-  verifyRuntime(runtime);
-
-  const mcpServers = readJson(path.join(args.generatedDir, "mcp-servers.json"));
-  if (!mcpServers.mcpServers || typeof mcpServers.mcpServers !== "object") {
-    fail("mcp-servers.json must include mcpServers object");
-  }
-  const serverEntries = Object.entries(mcpServers.mcpServers);
-  if (serverEntries.length === 0) {
-    fail("mcp-servers.json must include at least one server");
-  }
-  for (const [name, server] of serverEntries) {
-    assertServerShape(name, server);
-  }
-
-  const mcporter = readJson(path.join(args.generatedDir, "mcporter.json"));
-  if (!Array.isArray(mcporter.imports) || mcporter.imports.length === 0) {
-    fail("mcporter.json must include imports array");
-  }
-  if (!mcporter.mcpServers || typeof mcporter.mcpServers !== "object") {
-    fail("mcporter.json must include mcpServers object");
-  }
-
-  const openclaw = readJson(path.join(args.generatedDir, "openclaw-memory-qmd.json"));
-  if (openclaw?.memory?.backend !== "qmd") {
-    fail("openclaw-memory-qmd.json must set memory.backend=qmd");
-  }
-
-  const manifest = readJson(path.join(args.generatedDir, "manifest.json"));
-  verifyManifest(manifest, args.generatedDir);
-
-  if (args.checkReproducibility) {
-    verifyReproducibility(args.configPath, args.generatedDir);
-  }
-
-  console.log("MCP verification passed");
-}
-
-main();