Kiro Realtime Chat

Enables near real-time chat between multiple Kiro instances via a shared JSON file with polling for quick message exchange and task coordination.

Security Scan

The skill's code and instructions match its stated purpose (sharing messages via a local JSON file) and it does not request credentials or network access, but there are minor inconsistencies and safety/usability issues you should be aware of before installing.

Purpose & Capability

The name/description, SKILL.md, and the two included Python scripts are consistent: they read and write a shared JSON chat file to enable message exchange between Kiro instances. There are no unrelated credentials, binaries, or network integrations requested. Note: SKILL.md refers to memory/kiro-realtime.json while the scripts use ~/.openclaw/workspace/memory/kiro-realtime.json — a path mismatch that could cause confusion or misconfiguration.

Instruction Scope

All instructions and code operate on a local JSON file (create, read, write, mark read, poll). They do not call external endpoints or read unrelated system files. Concerns: no file locking or atomic-write handling is implemented (risk of race conditions/corruption under concurrent writers), and messages are stored in cleartext in the user's workspace where other local processes or users with access can read them.

Install Mechanism

No install spec or remote downloads — instruction-only plus included scripts. Nothing is fetched from external URLs and no archive extraction is performed.

Credentials

The skill requests no environment variables or credentials, which is proportionate. However, it writes chat data to a path inside the user's OpenClaw workspace (~/.openclaw/workspace/memory), so sensitive content placed in messages could be exposed to other local processes/users with filesystem access; that risk is inherent to the chosen storage method.

Persistence & Privilege

The skill is not marked always:true and is user-invocable only. It does not modify other skills' configuration or system-wide settings; it only reads/writes its own chat JSON file.

Assessment

This skill is coherent with its description and doesn't ask for credentials or network access, but review and consider the following before installing: (1) confirm which chat file path you want to use — SKILL.md and the scripts disagree, so correct the path to match your environment; (2) messages are stored as plaintext in your OpenClaw workspace (~/.openclaw/workspace/memory); only use this for non-sensitive content or restrict filesystem permissions accordingly; (3) the scripts lack file locking and atomic writes, so concurrent instances can corrupt the JSON file—consider adding file locks or write-to-temp-and-rename behavior; (4) polling at very short intervals increases disk I/O—choose an interval that balances responsiveness and load; (5) if you need stronger confidentiality or true real-time behavior, prefer an authenticated network-based solution (MCP/WebSocket) or add encryption. If you proceed, review the two included Python scripts and test in a safe environment first.

Overview

This skill enables near real-time communication between multiple Kiro instances using a shared JSON file with polling. Each message includes timestamp, sender, and content.

File Location

memory/kiro-realtime.json

JSON Structure

{
  "messages": [
    {
      "id": 1,
      "from": "VPS Kiro",
      "to": "Laptop Kiro",
      "message": "Selam!",
      "timestamp": "2026-03-05T22:58:00Z",
      "read": false
    }
  ],
  "lastCheck": "2026-03-05T22:58:00Z"
}

Usage

Sending a Message

import json
import os
from datetime import datetime

CHAT_FILE = "memory/kiro-realtime.json"

def send_message(from_name, to_name, message):
    # Load or create chat file
    if os.path.exists(CHAT_FILE):
        with open(CHAT_FILE, "r") as f:
            chat = json.load(f)
    else:
        chat = {"messages": [], "lastCheck": datetime.now().isoformat()}
    
    # Add new message
    msg_id = len(chat["messages"]) + 1
    chat["messages"].append({
        "id": msg_id,
        "from": from_name,
        "to": to_name,
        "message": message,
        "timestamp": datetime.now().isoformat(),
        "read": False
    })
    
    # Save
    with open(CHAT_FILE, "w") as f:
        json.dump(chat, f, indent=2)
    
    return msg_id

Checking for New Messages

def check_messages(my_name, since_timestamp=None):
    if not os.path.exists(CHAT_FILE):
        return []
    
    with open(CHAT_FILE, "r") as f:
        chat = json.load(f)
    
    # Update last check time
    chat["lastCheck"] = datetime.now().isoformat()
    with open(CHAT_FILE, "w") as f:
        json.dump(chat, f, indent=2)
    
    # Filter messages my_messages = []
 for me
       for msg in chat["messages"]:
        if msg["to"] == my_name and not msg["read"]:
            my_messages.append(msg)
            msg["read"] = True
    
    # Save read status
    with open(CHAT_FILE, "w") as f:
        json.dump(chat, f, indent=2)
    
    return my_messages

Polling Loop (for near real-time)

import time

def poll_messages(my_name, interval=5):
    """Poll for new messages every N seconds"""
    while True:
        msgs = check_messages(my_name)
        for msg in msgs:
            print(f"{msg['from']}: {msg['message']}")
            # Process and respond here
        time.sleep(interval)

Recommended Polling Interval

• Fast response needed: 2-3 seconds
• Normal: 5-10 seconds
• Low bandwidth: 30-60 seconds

Tips

• Mark messages as "read" after processing
• Use timestamps to avoid duplicate processing
• For better real-time, consider MCP server or WebSocket
• Keep messages under 1000 characters