@stamn/stamn-plugin 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/index.js

@@ -4764,7 +4764,7 @@ var StamnClient = class {
     return Math.random() * capped;
   }
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   async parseErrorResponse(res) {
     const body = await res.text();
@@ -5337,6 +5337,124 @@ function requestService(ws) {
     }
   };
 }
+function createServiceListing(ws, agentId) {
+  return {
+    name: "stamn_create_service_listing",
+    description: "Create a persistent service listing on the marketplace. This is your storefront \u2014 buyers browse these listings and purchase your services. Include a compelling description, fair price, and usage examples.",
+    parameters: {
+      type: "object",
+      properties: {
+        serviceTag: param("string", "Unique identifier, lowercase with underscores (e.g. 'code_review', 'summarize')."),
+        name: param("string", "Display name (e.g. 'Code Review', 'Text Summarization')."),
+        description: param("string", "Short description of what the service does (1-2 sentences)."),
+        priceCents: param("string", 'Price in USDC cents (e.g. "100" = $1.00).'),
+        category: param("string", "Service category.", {
+          enum: ["coding", "writing", "research", "analysis", "creative", "data", "other"]
+        }),
+        longDescription: param("string", "Detailed description shown on the service detail page. Markdown supported."),
+        inputDescription: param("string", "What input the service expects from the buyer."),
+        outputDescription: param("string", "What output the service produces."),
+        usageExamples: param("string", 'JSON array of {input, output} example pairs, e.g. [{"input":"Review this code...","output":"Found 3 issues..."}]'),
+        tags: param("string", 'Comma-separated tags for discovery (e.g. "python, fast, automated").'),
+        rateLimitPerHour: param("string", "Max requests per hour (optional)."),
+        estimatedDurationSeconds: param("string", "Estimated time to complete in seconds (optional).")
+      },
+      required: ["serviceTag", "name", "description", "priceCents"]
+    },
+    execute: (args) => {
+      const payload = {
+        participantId: agentId,
+        serviceTag: args.serviceTag,
+        name: args.name,
+        description: args.description,
+        priceCents: Number(args.priceCents)
+      };
+      if (args.category) payload.category = args.category;
+      if (args.longDescription) payload.longDescription = args.longDescription;
+      if (args.inputDescription) payload.inputDescription = args.inputDescription;
+      if (args.outputDescription) payload.outputDescription = args.outputDescription;
+      if (args.tags) {
+        payload.tags = args.tags.split(",").map((t2) => t2.trim()).filter(Boolean);
+      }
+      if (args.rateLimitPerHour) payload.rateLimitPerHour = Number(args.rateLimitPerHour);
+      if (args.estimatedDurationSeconds) payload.estimatedDurationSeconds = Number(args.estimatedDurationSeconds);
+      if (args.usageExamples) {
+        try {
+          payload.usageExamples = JSON.parse(args.usageExamples);
+        } catch {
+          return text("Error: usageExamples must be valid JSON array of {input, output} objects.");
+        }
+      }
+      ws.send("participant:service_listing_create", payload);
+      return text(`Service listing "${args.serviceTag}" creation sent. Check events for confirmation.`);
+    }
+  };
+}
+function updateServiceListing(ws) {
+  return {
+    name: "stamn_update_service_listing",
+    description: "Update an existing marketplace service listing. Use stamn_list_service_listings first to get the serviceId.",
+    parameters: {
+      type: "object",
+      properties: {
+        serviceId: param("string", "The service listing ID to update."),
+        name: param("string", "New display name."),
+        description: param("string", "New short description."),
+        priceCents: param("string", "New price in USDC cents."),
+        isActive: param("string", 'Set to "true" or "false" to enable/disable the listing.'),
+        category: param("string", "Service category.", {
+          enum: ["coding", "writing", "research", "analysis", "creative", "data", "other"]
+        }),
+        longDescription: param("string", "Detailed description (markdown supported)."),
+        inputDescription: param("string", "What input the service expects."),
+        outputDescription: param("string", "What output the service produces."),
+        usageExamples: param("string", "JSON array of {input, output} example pairs."),
+        tags: param("string", "Comma-separated tags."),
+        rateLimitPerHour: param("string", "Max requests per hour."),
+        estimatedDurationSeconds: param("string", "Estimated completion time in seconds.")
+      },
+      required: ["serviceId"]
+    },
+    execute: (args) => {
+      const payload = {
+        serviceId: args.serviceId
+      };
+      if (args.name) payload.name = args.name;
+      if (args.description) payload.description = args.description;
+      if (args.priceCents) payload.priceCents = Number(args.priceCents);
+      if (args.isActive !== void 0) payload.isActive = args.isActive === "true";
+      if (args.category) payload.category = args.category;
+      if (args.longDescription) payload.longDescription = args.longDescription;
+      if (args.inputDescription) payload.inputDescription = args.inputDescription;
+      if (args.outputDescription) payload.outputDescription = args.outputDescription;
+      if (args.tags) {
+        payload.tags = args.tags.split(",").map((t2) => t2.trim()).filter(Boolean);
+      }
+      if (args.rateLimitPerHour) payload.rateLimitPerHour = Number(args.rateLimitPerHour);
+      if (args.estimatedDurationSeconds) payload.estimatedDurationSeconds = Number(args.estimatedDurationSeconds);
+      if (args.usageExamples) {
+        try {
+          payload.usageExamples = JSON.parse(args.usageExamples);
+        } catch {
+          return text("Error: usageExamples must be valid JSON array of {input, output} objects.");
+        }
+      }
+      ws.send("participant:service_listing_update", payload);
+      return text(`Service listing update sent. Check events for confirmation.`);
+    }
+  };
+}
+function listServiceListings(ws) {
+  return {
+    name: "stamn_list_service_listings",
+    description: "List all your marketplace service listings (both active and inactive). Returns listing IDs, names, prices, and status.",
+    parameters: NO_PARAMS,
+    execute: () => {
+      ws.send("participant:service_listing_list", {});
+      return text("Service listing request sent. Check events for the list.");
+    }
+  };
+}
 function chatReply(ws, agentId) {
   return {
     name: "stamn_chat_reply",
@@ -5405,6 +5523,9 @@ function allTools(ws, agentId) {
     registerService(ws, agentId),
     respondToService(ws),
     requestService(ws),
+    createServiceListing(ws, agentId),
+    updateServiceListing(ws),
+    listServiceListings(ws),
     chatReply(ws, agentId),
     spend(ws)
   ];
@@ -5459,13 +5580,16 @@ function readLogs(opts) {
   try {
     stat = statSync(file);
   } catch {
-    return { lines: [], cursor: 0, size: 0, file, truncated: false, reset: false };
+    return { lines: [], cursor: 0, startCursor: 0, size: 0, file, truncated: false, reset: false };
   }
   const size = stat.size;
   const reset = cursor > size;
   if (reset) cursor = 0;
+  if (opts.fromEnd) {
+    cursor = Math.max(0, size - maxBytes);
+  }
   if (cursor >= size) {
-    return { lines: [], cursor, size, file, truncated: false, reset };
+    return { lines: [], cursor, startCursor: cursor, size, file, truncated: false, reset };
   }
   const bytesToRead = Math.min(maxBytes, size - cursor);
   const buffer = Buffer.alloc(bytesToRead);
@@ -5500,6 +5624,7 @@ function readLogs(opts) {
   return {
     lines,
     cursor: cursor + actualBytesConsumed,
+    startCursor: cursor,
     size,
     file,
     truncated: truncated || !atEof,
@@ -5507,6 +5632,57 @@ function readLogs(opts) {
   };
 }
 
+// src/workspace-files.ts
+import { readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync4, statSync as statSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6, resolve, relative, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
+var WORKSPACE_DIR = join6(homedir3(), ".openclaw", "workspace");
+function assertWithinWorkspace(relativePath) {
+  const full = resolve(WORKSPACE_DIR, relativePath);
+  if (!full.startsWith(WORKSPACE_DIR + "/") && full !== WORKSPACE_DIR) {
+    throw new Error("Path outside workspace");
+  }
+  return full;
+}
+function walkDir(dir, base) {
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(fullPath, base));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const stat = statSync2(fullPath);
+      results.push({
+        path: relative(base, fullPath),
+        size: stat.size,
+        modifiedAt: stat.mtime.toISOString()
+      });
+    }
+  }
+  return results;
+}
+function listWorkspaceFiles() {
+  return walkDir(WORKSPACE_DIR, WORKSPACE_DIR);
+}
+function readWorkspaceFile(relativePath) {
+  const full = assertWithinWorkspace(relativePath);
+  const content = readFileSync3(full, "utf-8");
+  const stat = statSync2(full);
+  return { path: relativePath, content, size: stat.size };
+}
+function writeWorkspaceFile(relativePath, content) {
+  const full = assertWithinWorkspace(relativePath);
+  mkdirSync3(dirname2(full), { recursive: true });
+  writeFileSync4(full, content, "utf-8");
+  return { path: relativePath, written: true };
+}
+
 // src/ws-service.ts
 var MAX_EVENT_BUFFER_SIZE = 200;
 var BASE_RECONNECT_DELAY_MS = 1e3;
@@ -5678,6 +5854,18 @@ var StamnWsService = class {
       this.handleRequestLogs(payload.params);
       return;
     }
+    if (payload.command === "list_files") {
+      this.handleListFiles(payload.params);
+      return;
+    }
+    if (payload.command === "read_file") {
+      this.handleReadFile(payload.params);
+      return;
+    }
+    if (payload.command === "write_file") {
+      this.handleWriteFile(payload.params);
+      return;
+    }
     this.logger.info(`Command received: ${payload.command} (${payload.commandId})`);
     if (payload.command === "update_plugin") {
       this.handleUpdatePlugin();
@@ -5702,7 +5890,8 @@ var StamnWsService = class {
       const result = readLogs({
         cursor: params.cursor,
         limit: params.limit,
-        maxBytes: params.maxBytes
+        maxBytes: params.maxBytes,
+        fromEnd: params.fromEnd
       });
       this.sendMessage("participant:log_response", {
         requestId: params.requestId,
@@ -5722,6 +5911,54 @@ var StamnWsService = class {
       });
     }
   }
+  handleListFiles(params) {
+    try {
+      const files = listWorkspaceFiles();
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        files
+      });
+    } catch (err) {
+      this.sendMessage("participant:file_response", {
+        requestId: params.requestId,
+        files: [],
+        error: err.message
+      });
+    }
+  }
+  handleReadFile(params) {
+    try {
+      const result = readWorkspaceFile(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
+      });
+    }
+  }
+  handleWriteFile(params) {
+    try {
+      const result = writeWorkspaceFile(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
+      });
+    }
+  }
   onAuthError(payload) {
     this.authFailed = true;
     this.logger.error(`Authentication failed: ${payload.reason}`);