@context-use/openclaw-memory 0.1.0-beta.109

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+The Radiance Cascades shader portions in packages/ui/src/components/brand/light/shaders
+(radiance-cascade.wgsl, rc-directions.wgsl, and sdf-sample.wgsl), and the frame-health
+monitor in packages/ui/src/components/brand/light/frame-health.ts:
+Copyright (c) 2025 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bootstrap.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+// package.json
+var package_default = {
+  name: "@context-use/openclaw-memory",
+  version: "0.1.0-beta.109",
+  description: "Context Use as OpenClaw's sole durable personal memory",
+  type: "module",
+  license: "MIT",
+  bin: {
+    "context-use-openclaw": "./pkg/dist/bootstrap.js"
+  },
+  openclaw: {
+    extensions: [
+      "./dist/index.js"
+    ]
+  },
+  scripts: {
+    "check:types": "bun run --bun tsc",
+    test: "bun test test",
+    "test:e2e": "bun run pack:release && bun run scripts/e2e.ts",
+    "test:published": "bun run scripts/e2e.ts --published",
+    "pack:release": "bun run build:plugin && bun run scripts/pack.ts",
+    "build:plugin": "bun run scripts/build.ts"
+  },
+  peerDependencies: {
+    openclaw: ">=2026.9.4"
+  },
+  devDependencies: {
+    "@repo/browser-testing": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/semver": "^7.8.0",
+    openclaw: "2026.9.4",
+    typescript: "catalog:"
+  },
+  dependencies: {
+    "@modelcontextprotocol/client": "^2",
+    "proper-lockfile": "^4.1.2",
+    semver: "^7.8.5",
+    typebox: "^1",
+    zod: "^4.4.3"
+  },
+  private: true,
+  engines: {
+    node: "^24.16.0 || >=26.1.0"
+  },
+  peerDependenciesMeta: {
+    openclaw: {
+      optional: true
+    }
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/massimoalbarello/context-use.git",
+    directory: "packages/openclaw-memory"
+  },
+  homepage: "https://github.com/massimoalbarello/context-use",
+  bugs: {
+    url: "https://github.com/massimoalbarello/context-use/issues"
+  },
+  publishConfig: {
+    access: "public",
+    tag: "beta"
+  },
+  exports: {
+    "./setup-prompt": "./src/setup-prompt.ts"
+  }
+};
+
+// src/setup-prompt.ts
+var OPENCLAW_PACKAGE = `${package_default.name}@${package_default.publishConfig.tag}`;
+var OPENCLAW_NPM_URL = `https://www.npmjs.com/package/${package_default.name}`;
+var OPENCLAW_REQUIREMENT = package_default.peerDependencies.openclaw;
+var OPENCLAW_INSTALL_COMMAND = `npx --yes ${OPENCLAW_PACKAGE}`;
+function openclawConnectCommand(serverUrl) {
+  return `${OPENCLAW_INSTALL_COMMAND} connect '${serverUrl.replaceAll("'", "'\\''")}'`;
+}
+function openclawSetupPrompt(serverUrl) {
+  return `Install Context Use as my sole durable personal memory in this OpenClaw agent. Keep my conversations separate.
+
+Check openclaw --version first (requires ${OPENCLAW_REQUIREMENT}), then run:
+${openclawConnectCommand(serverUrl)}
+
+Follow the plugin's instructions: give me the authorization URL and ask me to return the final localhost redirect URL. When I send it back, finish connecting. Let the plugin manage configuration and gateway refresh.
+
+After authorization, verify openclaw context-use status. If connected and authenticated, confirm that setup is complete and tell me to start a new session with /new so the memory tools become available.`;
+}
+var OPENCLAW_REMOVAL_PROMPT = `Remove the Context Use memory plugin using ${OPENCLAW_INSTALL_COMMAND} remove in this OpenClaw profile. This also works if authorization was never completed or the plugin is disabled. Let the plugin restore its configuration changes, clear its credentials and refresh the gateway. Preserve my remote memories and conversation history. Verify that a fresh conversation uses the restored memory provider.`;
+
+// src/bootstrap.ts
+import { join as join2 } from "node:path";
+import { satisfies as satisfies2 } from "semver";
+
+// src/contract.ts
+import { satisfies } from "semver";
+import { z } from "zod";
+
+// src/error.ts
+class ConnectionError extends Error {
+}
+
+// src/contract.ts
+var PLUGIN_ID = "context-use";
+var PACKAGE_VERSION = package_default.version;
+var OPENCLAW_VERSION_RANGE = package_default.peerDependencies.openclaw;
+var CALLBACK_URL = "http://127.0.0.1:49187/context-use/callback";
+var REQUEST_TIMEOUT_MS = 30000;
+var AUTHORIZATION_TIMEOUT_MS = 600000;
+var AUTHORIZATION_SCOPE = "mcp offline_access";
+var toolName = (name) => `context_use_${name}`;
+var FINISH_LEARNING_TOOL = toolName("finish_learning");
+var SAVE_ATTACHMENT_TOOL = toolName("save_learning_attachment");
+var PluginConfigSchema = z.strictObject({
+  agentId: z.string().regex(/^[a-z0-9][a-z0-9_-]*$/),
+  serverUrl: z.url()
+});
+function serverUrl(input) {
+  const url = new URL(input);
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    throw new ConnectionError("Use an HTTPS instance URL (HTTP is allowed only for local development).");
+  }
+  if (url.username || url.password || url.search || url.hash || !["/", "/mcp"].includes(url.pathname)) {
+    throw new ConnectionError("Supply the instance origin or its /mcp endpoint, without credentials or query parameters.");
+  }
+  return new URL("/mcp", url).href;
+}
+function assertHostVersion(version) {
+  if (!satisfies(version, OPENCLAW_VERSION_RANGE)) {
+    throw new ConnectionError(`This plugin requires OpenClaw ${OPENCLAW_VERSION_RANGE}; found ${version}.`);
+  }
+}
+var MCP_TOOL_NAMES = [
+  "create_asset_upload",
+  "list_assets",
+  "read_asset",
+  "update_asset",
+  "archive_asset",
+  "create_entity",
+  "list_entities",
+  "read_entity",
+  "update_entity",
+  "archive_entity",
+  "search_hypermedia",
+  "read_hypermedia_curation_guide",
+  "create_knowledge_page",
+  "list_knowledge_pages",
+  "read_knowledge_page",
+  "update_knowledge_page",
+  "archive_knowledge_page",
+  "read_record"
+];
+
+// src/gateway.ts
+import { resolve } from "node:path";
+import { z as z2 } from "zod";
+
+// src/host-command.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var HOST_TIMEOUT_MS = 120000;
+async function runSetupCommand(input) {
+  const child = spawn(process.execPath, [input.script, ...input.args], { stdio: "inherit" });
+  return await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+}
+async function openclaw(args) {
+  const result = await execute("openclaw", args, {
+    timeout: HOST_TIMEOUT_MS,
+    maxBuffer: 4000000
+  });
+  return result.stdout;
+}
+async function checkHost() {
+  const output = await openclaw(["--version"]);
+  const version = output.match(/\b\d{4}\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
+  if (!version) {
+    throw new ConnectionError("Could not determine the installed OpenClaw version.");
+  }
+  assertHostVersion(version);
+}
+
+// src/gateway.ts
+async function refreshGateway() {
+  const local = z2.object({ path: z2.string() }).parse(JSON.parse(await openclaw(["config", "file", "--json"])));
+  let remote;
+  try {
+    remote = z2.object({ path: z2.string() }).parse(JSON.parse(await openclaw(["gateway", "call", "config.get", "--timeout", "3000", "--json"])));
+  } catch {
+    console.log(`Settings saved. No reachable gateway was verified; they apply on its next start. Run ${OPENCLAW_INSTALL_COMMAND} refresh to retry.`);
+    return;
+  }
+  if (resolve(remote.path) !== resolve(local.path)) {
+    throw new ConnectionError(`Settings saved, but the running gateway uses another configuration. Start this profile’s gateway, then run ${OPENCLAW_INSTALL_COMMAND} refresh.`);
+  }
+  const result = z2.object({ ok: z2.boolean() }).parse(JSON.parse(await openclaw([
+    "gateway",
+    "call",
+    "gateway.restart.request",
+    "--params",
+    JSON.stringify({ reason: "Context Use memory configuration changed" }),
+    "--json"
+  ])));
+  if (!result.ok) {
+    throw new ConnectionError(`Settings saved, but gateway refresh was not accepted. Run ${OPENCLAW_INSTALL_COMMAND} refresh to retry.`);
+  }
+  console.log("Gateway refresh requested. OpenClaw will apply the change after active work finishes.");
+}
+
+// src/package-installation.ts
+import { execFile as execFile2 } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify as promisify2 } from "node:util";
+import { z as z3 } from "zod";
+var execute2 = promisify2(execFile2);
+var INSTALL_TIMEOUT_MS = 120000;
+async function installedPlugin() {
+  const inventory = z3.object({
+    plugins: z3.array(z3.object({
+      id: z3.string(),
+      rootDir: z3.string()
+    }))
+  }).parse(JSON.parse(await openclaw(["plugins", "list", "--json"])));
+  return inventory.plugins.find((plugin) => plugin.id === PLUGIN_ID);
+}
+async function installPackage() {
+  const existing = await installedPlugin();
+  if (existing) {
+    const installed = z3.object({ name: z3.string() }).parse(JSON.parse(await readFile(join(existing.rootDir, "package.json"), "utf8")));
+    if (installed.name !== package_default.name) {
+      throw new ConnectionError(`The context-use plugin ID belongs to another package: ${installed.name}.`);
+    }
+    return;
+  }
+  const root = resolve2(dirname(fileURLToPath(import.meta.url)), "..");
+  const directory = await mkdtemp(join(tmpdir(), "context-use-install-"));
+  try {
+    const packed = await execute2("npm", ["pack", root, "--ignore-scripts", "--json", "--pack-destination", directory], { timeout: INSTALL_TIMEOUT_MS });
+    const [{ filename }] = z3.tuple([z3.object({ filename: z3.string() })]).parse(JSON.parse(packed.stdout));
+    console.log(await openclaw([
+      "plugins",
+      "install",
+      join(directory, filename),
+      "--force",
+      "--accept-capabilities"
+    ]));
+  } catch (error) {
+    if (error && typeof error === "object" && "stderr" in error && typeof error.stderr === "string") {
+      process.stderr.write(error.stderr);
+    }
+    throw new ConnectionError("OpenClaw could not install Context Use. Resolve the installer error above and retry connect.");
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+// src/usage.ts
+var SETUP_USAGE = `context-use-openclaw connect <instance-url> [agent-id=main]
+context-use-openclaw authorize
+context-use-openclaw status
+context-use-openclaw disconnect
+context-use-openclaw remove
+context-use-openclaw refresh
+
+Connect installs the plugin and starts browser authorization. Pass the returned URL to authorize
+through standard input. After installation, these commands also work through openclaw context-use.
+Use the same OpenClaw profile for every command. Remove restores your settings and uninstalls the
+plugin while preserving remote memories. Refresh also works after uninstall.`;
+
+// src/bootstrap.ts
+async function main(args) {
+  if (!args[0] || args[0] === "--help") {
+    console.log(SETUP_USAGE);
+    return;
+  }
+  if (!satisfies2(process.versions.node, package_default.engines.node)) {
+    throw new ConnectionError(`This setup command requires Node ${package_default.engines.node}; found ${process.versions.node}. Use the Node runtime supported by your OpenClaw installation.`);
+  }
+  if (args[0] === "connect") {
+    if (!args[1]) {
+      throw new ConnectionError("Provide the Context Use instance URL.");
+    }
+    serverUrl(args[1]);
+  }
+  await checkHost();
+  if (args[0] === "refresh") {
+    await refreshGateway();
+    return;
+  }
+  if (args[0] === "connect") {
+    await installPackage();
+  }
+  const installed = await installedPlugin();
+  if (!installed) {
+    throw new ConnectionError("Context Use is not installed. Run connect first.");
+  }
+  process.exitCode = await runSetupCommand({
+    script: join2(installed.rootDir, "dist/setup.js"),
+    args
+  });
+}
+try {
+  await main(process.argv.slice(2));
+} catch (error) {
+  console.error(error instanceof ConnectionError ? error.message : "Context Use installation failed. Check the OpenClaw installation and retry.");
+  process.exitCode = 1;
+}