@stamn/stamn-plugin 0.1.0-alpha.32 → 0.1.0-alpha.34

package/dist/index.js

@@ -4472,7 +4472,7 @@ ${l}
   }
 } }).prompt();
 
-// node_modules/.pnpm/@stamn+sdk@0.1.0-alpha.2/node_modules/@stamn/sdk/dist/index.js
+// node_modules/.pnpm/@stamn+sdk@0.1.0-alpha.3/node_modules/@stamn/sdk/dist/index.js
 var Resource = class {
   constructor(client) {
     this.client = client;
@@ -4676,6 +4676,42 @@ var ServicesResource = class extends Resource {
     );
   }
 };
+var RuntimeResource = class extends Resource {
+  async listHosts() {
+    const res = await this.client.request(
+      "GET",
+      "/v1/runtime/hosts"
+    );
+    return res.data;
+  }
+  async listFiles(scope, hostname2) {
+    const params = new URLSearchParams({ scope });
+    if (hostname2) params.set("hostname", hostname2);
+    const res = await this.client.request("GET", `/v1/runtime/files?${params}`);
+    return res.data.files;
+  }
+  async readFile(scope, path, hostname2) {
+    const params = new URLSearchParams({ scope, path });
+    if (hostname2) params.set("hostname", hostname2);
+    const res = await this.client.request("GET", `/v1/runtime/files/read?${params}`);
+    return res.data;
+  }
+  async writeFile(scope, path, content, hostname2) {
+    const res = await this.client.request("PATCH", "/v1/runtime/files/write", { scope, path, content, hostname: hostname2 });
+    return res.data;
+  }
+  async readConfig(hostname2) {
+    const params = new URLSearchParams();
+    if (hostname2) params.set("hostname", hostname2);
+    const qs = params.toString();
+    const res = await this.client.request("GET", `/v1/runtime/config${qs ? `?${qs}` : ""}`);
+    return res.data;
+  }
+  async writeConfig(content, hostname2) {
+    const res = await this.client.request("PATCH", "/v1/runtime/config", { content, hostname: hostname2 });
+    return res.data;
+  }
+};
 var StamnApiError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -4702,6 +4738,7 @@ var StamnClient = class {
   leaderboard;
   health;
   services;
+  runtime;
   constructor(options = {}) {
     this.apiKey = options.apiKey;
     this.retryOptions = { ...DEFAULT_RETRY, ...options.retry };
@@ -4713,6 +4750,7 @@ var StamnClient = class {
     this.leaderboard = new LeaderboardResource(this);
     this.health = new HealthResource(this);
     this.services = new ServicesResource(this);
+    this.runtime = new RuntimeResource(this);
   }
   setApiKey(apiKey) {
     this.apiKey = apiKey;
@@ -4767,7 +4805,7 @@ var StamnClient = class {
     return Math.random() * capped;
   }
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   async parseErrorResponse(res) {
     const body = await res.text();
@@ -4781,7 +4819,7 @@ var StamnClient = class {
   }
 };
 
-// node_modules/.pnpm/@stamn+cli@0.1.0-alpha.7/node_modules/@stamn/cli/dist/chunk-Z2IAJQOV.js
+// node_modules/.pnpm/@stamn+cli@0.1.0-alpha.10/node_modules/@stamn/cli/dist/chunk-VAKVDZRN.js
 import { execSync } from "child_process";
 import { mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
@@ -4862,7 +4900,7 @@ async function handleAgentRegister(opts, adapter) {
     const match = agents.find((a) => a.name === name);
     if (match) {
       s.stop("Agent found.");
-      adapter.writeConfig({ agentId: match.id, agentName: match.name });
+      writeResult(adapter, name, match.id, match.name, config.apiKey);
       R2.success(`Agent "${match.name}" (${match.id}) already exists. Selected as active.`);
       Gt("Done!");
       process.exit(0);
@@ -4870,8 +4908,9 @@ async function handleAgentRegister(opts, adapter) {
     s.start("Registering agent...");
     const participant = await client.participants.create({ name });
     s.stop("Agent registered.");
-    adapter.writeConfig({ agentId: participant.id, agentName: participant.name });
+    writeResult(adapter, name, participant.id, participant.name, config.apiKey);
     R2.success(`Agent "${participant.name}" (${participant.id})`);
+    R2.info(`Bound to OpenClaw agent "${name}".`);
     Gt("Done!");
     process.exit(0);
   } catch (err) {
@@ -4880,6 +4919,10 @@ async function handleAgentRegister(opts, adapter) {
     process.exit(1);
   }
 }
+function writeResult(adapter, name, agentId, agentName, apiKey) {
+  adapter.writeAgentBinding(name, { agentId, apiKey, agentName });
+  adapter.writeConfig({ agentId, agentName });
+}
 async function handleAgentList(_opts, adapter) {
   Wt2("Stamn Agents");
   const config = adapter.readConfig();
@@ -4927,8 +4970,13 @@ async function handleAgentSelect(opts, adapter) {
       process.exit(1);
       return;
     }
-    adapter.writeConfig({ agentId: match.id, agentName: match.name });
-    R2.success(`Active agent set to "${match.name}" (${match.id})`);
+    if (opts.bind) {
+      adapter.writeAgentBinding(opts.bind, { agentId: match.id, apiKey: config.apiKey, agentName: match.name });
+      R2.success(`Agent "${match.name}" (${match.id}) bound to OpenClaw agent "${opts.bind}".`);
+    } else {
+      adapter.writeConfig({ agentId: match.id, agentName: match.name });
+      R2.success(`Active agent set to "${match.name}" (${match.id})`);
+    }
     Gt("Done!");
     process.exit(0);
   } catch (err) {
@@ -5138,6 +5186,15 @@ function createOpenclawAdapter() {
       };
       writeJsonFile(getConfigPath(), config);
     },
+    writeAgentBinding(openclawAgentId, binding) {
+      const config = readOpenclawConfig();
+      ensurePluginConfig(config);
+      config.plugins.entries[PLUGIN_ID].enabled = true;
+      const pluginConfig = config.plugins.entries[PLUGIN_ID].config;
+      if (!pluginConfig.agents) pluginConfig.agents = {};
+      pluginConfig.agents[openclawAgentId] = binding;
+      writeJsonFile(getConfigPath(), config);
+    },
     readStatusFile() {
       return readJsonFile(join3(homedir(), ".openclaw", "stamn-status.json"));
     },
@@ -5222,7 +5279,7 @@ function registerCli(api) {
       const agent = stamn.command("agent").description("Agent management");
       agent.command("register").description("Register a new agent or reconnect to an existing one").option("--name <name>", "Agent name").action((opts) => handleAgentRegister(opts, adapter));
       agent.command("list").description("List agents under your account").action(() => handleAgentList({}, adapter));
-      agent.command("select").description("Set active agent").argument("<nameOrId>", "Agent name or ID").action((nameOrId) => handleAgentSelect({ nameOrId }, adapter));
+      agent.command("select").description("Set active agent").argument("<nameOrId>", "Agent name or ID").option("--bind <agentId>", "Bind to a specific OpenClaw agent ID (for multi-agent setups)").action((nameOrId, opts) => handleAgentSelect({ nameOrId, ...opts }, adapter));
       agent.command("config").description("View or update agent configuration").option("--name <name>", "Agent display name").option("--personality", "Open editor to set agent personality").action((opts) => handleConfig(opts, adapter));
       stamn.command("status").description("Show connection status and server health").action(() => handleStatus(adapter));
       stamn.command("update").description("Update the Stamn plugin to the latest version").action(() => handleUpdate());
@@ -5394,6 +5451,114 @@ function writeWorkspaceFile(relativePath, content) {
   return { path: relativePath, written: true };
 }
 
+// src/global-files.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync5, statSync as statSync3, mkdirSync as mkdirSync4, realpathSync as realpathSync2, existsSync as existsSync3 } from "fs";
+import { join as join7, resolve as resolve2, relative as relative2, dirname as dirname3 } from "path";
+import { homedir as homedir4 } from "os";
+var OPENCLAW_DIR = join7(homedir4(), ".openclaw");
+var CONFIG_FILE = join7(OPENCLAW_DIR, "openclaw.json");
+var SCOPE_DIRS = {
+  skills: join7(OPENCLAW_DIR, "skills"),
+  workspace: join7(OPENCLAW_DIR, "workspace"),
+  config: OPENCLAW_DIR
+};
+function resolveBaseDir(scope) {
+  const dir = SCOPE_DIRS[scope];
+  if (!dir) throw new Error(`Invalid scope: ${scope}`);
+  return dir;
+}
+function realBase(dir) {
+  try {
+    return realpathSync2(dir);
+  } catch {
+    return dir;
+  }
+}
+function assertWithinScope(scope, relativePath) {
+  const base = resolveBaseDir(scope);
+  const full = resolve2(base, relativePath);
+  if (!full.startsWith(base + "/") && full !== base) {
+    throw new Error("Path outside scope");
+  }
+  const baseReal = realBase(base);
+  try {
+    const realFull = realpathSync2(full);
+    if (!realFull.startsWith(baseReal + "/") && realFull !== baseReal) {
+      throw new Error("Path outside scope");
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      try {
+        const parentReal = realpathSync2(dirname3(full));
+        if (!parentReal.startsWith(baseReal + "/") && parentReal !== baseReal) {
+          throw new Error("Path outside scope");
+        }
+      } catch {
+      }
+    } else {
+      throw err;
+    }
+  }
+  return full;
+}
+function walkDir2(dir, base) {
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = join7(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir2(fullPath, base));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const stat = statSync3(fullPath);
+      results.push({
+        path: relative2(base, fullPath),
+        size: stat.size,
+        modifiedAt: stat.mtime.toISOString()
+      });
+    }
+  }
+  return results;
+}
+function listGlobalFiles(scope) {
+  const base = resolveBaseDir(scope);
+  return walkDir2(base, base);
+}
+function readGlobalFile(scope, relativePath) {
+  const full = assertWithinScope(scope, relativePath);
+  const content = readFileSync4(full, "utf-8");
+  const stat = statSync3(full);
+  return { path: relativePath, content, size: stat.size };
+}
+function writeGlobalFile(scope, relativePath, content) {
+  const full = assertWithinScope(scope, relativePath);
+  mkdirSync4(dirname3(full), { recursive: true });
+  writeFileSync5(full, content, "utf-8");
+  return { path: relativePath, written: true };
+}
+function readOpenclawConfig2() {
+  if (!existsSync3(CONFIG_FILE)) {
+    return { path: "openclaw.json", content: "{}", size: 2 };
+  }
+  const content = readFileSync4(CONFIG_FILE, "utf-8");
+  const stat = statSync3(CONFIG_FILE);
+  return { path: "openclaw.json", content, size: stat.size };
+}
+function writeOpenclawConfig(content) {
+  try {
+    JSON.parse(content);
+  } catch {
+    throw new Error("Invalid JSON: config must be valid JSON");
+  }
+  mkdirSync4(dirname3(CONFIG_FILE), { recursive: true });
+  writeFileSync5(CONFIG_FILE, content, "utf-8");
+  return { path: "openclaw.json", written: true };
+}
+
 // src/ws-service.ts
 var MAX_EVENT_BUFFER_SIZE = 200;
 var BASE_RECONNECT_DELAY_MS = 1e3;
@@ -5583,6 +5748,26 @@ var StamnWsService = class {
       this.handleWriteFile(payload.params);
       return;
     }
+    if (payload.command === "list_global_files") {
+      this.handleListGlobalFiles(payload.params);
+      return;
+    }
+    if (payload.command === "read_global_file") {
+      this.handleReadGlobalFile(payload.params);
+      return;
+    }
+    if (payload.command === "write_global_file") {
+      this.handleWriteGlobalFile(payload.params);
+      return;
+    }
+    if (payload.command === "read_openclaw_config") {
+      this.handleReadOpenclawConfig(payload.params);
+      return;
+    }
+    if (payload.command === "write_openclaw_config") {
+      this.handleWriteOpenclawConfig(payload.params);
+      return;
+    }
     this.logger.info(`Command received: ${payload.command} (${payload.commandId})`);
     if (payload.command === "update_plugin") {
       this.handleUpdatePlugin();
@@ -5676,6 +5861,87 @@ var StamnWsService = class {
       });
     }
   }
+  handleListGlobalFiles(params) {
+    try {
+      const files = listGlobalFiles(params.scope);
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        files
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        files: [],
+        error: err.message
+      });
+    }
+  }
+  handleReadGlobalFile(params) {
+    try {
+      const result = readGlobalFile(params.scope, params.path);
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        ...result
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        path: params.path,
+        content: "",
+        size: 0,
+        error: err.message
+      });
+    }
+  }
+  handleWriteGlobalFile(params) {
+    try {
+      const result = writeGlobalFile(params.scope, params.path, params.content);
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        ...result
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        path: params.path,
+        written: false,
+        error: err.message
+      });
+    }
+  }
+  handleReadOpenclawConfig(params) {
+    try {
+      const result = readOpenclawConfig2();
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        ...result
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        path: "openclaw.json",
+        content: "",
+        size: 0,
+        error: err.message
+      });
+    }
+  }
+  handleWriteOpenclawConfig(params) {
+    try {
+      const result = writeOpenclawConfig(params.content);
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        ...result
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        path: "openclaw.json",
+        written: false,
+        error: err.message
+      });
+    }
+  }
   onAuthError(payload) {
     this.authFailed = true;
     this.logger.error(`Authentication failed: ${payload.reason}`);