@inceptionstack/roundhouse 0.5.8 → 0.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/cli/cron-commands.ts

@@ -105,9 +105,23 @@ export async function cronAdd(store: CronStore, positional: string[], flags: Rec
 }
 
 export async function cronList(store: CronStore, _positional: string[], flags: Record<string, string>): Promise<void> {
-  const jobs = await store.listJobs();
+  let jobs = await store.listJobs();
+
+  // Hide completed one-shot jobs unless --all flag is set
+  if (!flags.all) {
+    const filtered: typeof jobs = [];
+    for (const j of jobs) {
+      if (j.schedule.type === "once") {
+        const state = await store.getState(j.id);
+        if (state.totalRuns > 0) continue;
+      }
+      filtered.push(j);
+    }
+    jobs = filtered;
+  }
+
   if (jobs.length === 0) {
-    console.log("No cron jobs configured.");
+    console.log("No active cron jobs.");
     return;
   }
   if (flags.json) {

package/src/cron/runner.ts

@@ -6,8 +6,8 @@
  */
 
 import { getAgentFactory } from "../agents/registry";
-// TODO: route through TransportAdapter.notify() when multi-transport lands
 import { sendTelegramToMany } from "../transports/telegram/notify";
+import { sendIpc } from "../ipc";
 import { CronStore, generateRunId } from "./store";
 import { buildTemplateContext, renderTemplate } from "./template";
 import type { CronJobConfig, CronRunRecord } from "./types";
@@ -20,6 +20,7 @@ export class CronRunner {
   constructor(
     private store: CronStore,
     private agentConfig?: GatewayConfig["agent"],
+    private notifyFn?: (text: string) => Promise<void>,
   ) {}
 
   async runJob(
@@ -127,10 +128,9 @@ export class CronRunner {
   }
 
   private async notify(job: CronJobConfig, record: CronRunRecord): Promise<void> {
+    // Apply onlyOn filter if configured (for both routes)
     const tg = job.notify?.telegram;
-    if (!tg?.chatIds?.length) return;
-
-    if (!shouldNotify(tg.onlyOn, record.status)) return;
+    if (tg?.onlyOn && !shouldNotify(tg.onlyOn, record.status)) return;
 
     const icon = runStatusIcon(record.status);
     const dur = `${(record.durationMs / 1000).toFixed(1)}s`;
@@ -145,6 +145,27 @@ export class CronRunner {
       body = `${header}\nError: ${record.error.slice(0, NOTIFY_MAX_ERROR_CHARS)}`;
     }
 
-    await sendTelegramToMany(tg.chatIds, body);
+    // Route 1: Explicit Telegram chat IDs configured on the job
+    if (tg?.chatIds?.length) {
+      await sendTelegramToMany(tg.chatIds, body);
+      return;
+    }
+
+    // Route 2: Direct callback from gateway (no loopback socket)
+    if (this.notifyFn) {
+      try {
+        await this.notifyFn(body);
+      } catch (err) {
+        console.warn(`[cron] ${job.id} notify callback failed:`, (err as Error).message);
+      }
+      return;
+    }
+
+    // Route 3: Fallback to IPC (for CLI-triggered runs outside gateway)
+    try {
+      await sendIpc({ type: "notify", text: body });
+    } catch {
+      console.warn(`[cron] ${job.id} IPC notify failed (gateway not running?)`);
+    }
   }
 }

package/src/cron/scheduler.ts

@@ -41,9 +41,9 @@ export class CronSchedulerService {
   private lastHeartbeatAt = 0; // 0 = fires on first tick after startup (intentional catch-up)
   private tickMs: number;
 
-  constructor(private opts?: { tickMs?: number; agentConfig?: GatewayConfig["agent"]; notifyChatIds?: number[] }) {
+  constructor(private opts?: { tickMs?: number; agentConfig?: GatewayConfig["agent"]; notifyChatIds?: number[]; notifyFn?: (text: string) => Promise<void> }) {
     this.store = new CronStore();
-    this.runner = new CronRunner(this.store, this.opts?.agentConfig);
+    this.runner = new CronRunner(this.store, this.opts?.agentConfig, this.opts?.notifyFn);
     this.queue = new PQueue({ concurrency: 1 });
     this.tickMs = this.opts?.tickMs ?? TICK_MS;
   }
@@ -88,10 +88,19 @@ export class CronSchedulerService {
 
   async listJobs(): Promise<Array<{ job: CronJobConfig; state: CronJobState }>> {
     await this.reload();
-    return this.jobs.map((job) => ({
-      job,
-      state: this.states.get(job.id) ?? emptyState(job.id),
-    }));
+    return this.jobs
+      .filter((job) => {
+        // Hide completed one-shot jobs (already fired, won't run again)
+        if (job.schedule.type === "once") {
+          const state = this.states.get(job.id);
+          if (state && state.totalRuns > 0) return false;
+        }
+        return true;
+      })
+      .map((job) => ({
+        job,
+        state: this.states.get(job.id) ?? emptyState(job.id),
+      }));
   }
 
   async trigger(jobId: string): Promise<void> {

package/src/gateway/gateway.ts

@@ -325,6 +325,12 @@ export class Gateway {
     this.cronScheduler = new CronSchedulerService({
       agentConfig: this.config.agent,
       notifyChatIds: this.config.chat.notifyChatIds,
+      notifyFn: async (text: string) => {
+        const chatIds = this.config.chat.notifyChatIds;
+        if (chatIds?.length && this.transport) {
+          await this.transport.notify(chatIds, text);
+        }
+      },
     });
     try {
       await this.cronScheduler.start();

package/src/gateway/tools.md

@@ -52,3 +52,117 @@ Users can also manage jobs via Telegram:
 - `/crons trigger <id>` — run now
 - `/crons pause <id>` — disable
 - `/crons resume <id>` — enable
+
+## roundhouse message
+
+Send a message to the user via all active transports (Telegram, etc.) without spawning an agent turn.
+
+**Usage:**
+```bash
+roundhouse message "Hello from the server!"
+roundhouse message --session main "Targeted to primary chat"
+```
+
+## Git & GitHub (gh CLI)
+
+Use `gh` CLI for all GitHub operations. It handles authentication automatically.
+
+**Common patterns:**
+```bash
+# Push branches
+git push origin <branch>
+
+# Create PRs
+gh pr create --base main --head <branch> --title "..." --body "..."
+
+# Merge PRs
+gh pr merge <number> --squash --admin
+
+# Check CI status
+gh pr checks <number>
+gh run list --limit 5
+
+# Create releases / tags
+git tag v1.2.3 && git push origin v1.2.3
+```
+
+**Prefer `gh` over raw git for:**
+- PR creation and merging
+- CI/workflow status checks
+- Release creation
+- Repository settings
+
+## mcporter (MCP Server CLI)
+
+Call tools from configured MCP servers (AWS APIs, docs, infrastructure).
+
+```bash
+mcporter list                          # show available servers
+mcporter list <server> --schema        # show tools + parameters
+mcporter call <server>.<tool> key=val   # call a tool
+```
+
+**Examples:**
+```bash
+mcporter call 'aws-mcp.sts_GetCallerIdentity()'
+mcporter call aws-mcp.s3_ListBuckets
+mcporter call 'aws-documentation.search(query: "Lambda timeout")'
+```
+
+> Ensure PATH includes `~/.local/bin` for `mcporter`/`uvx` discovery.
+
+## playwright-cli (Browser Automation)
+
+Headless browser automation for testing web UIs, scraping, screenshots.
+
+**Core workflow:** open → snapshot → interact → close
+
+```bash
+playwright-cli open "https://example.com"   # launch + navigate
+playwright-cli snapshot                      # accessibility tree with [ref=eN]
+playwright-cli click e5                      # click element by ref
+playwright-cli fill e3 "search query"        # type into input
+playwright-cli screenshot                    # save viewport PNG
+playwright-cli close                         # close browser
+```
+
+**Other commands:**
+```bash
+playwright-cli requests               # list network requests
+playwright-cli request <index>        # show request details
+playwright-cli cookie-list            # list cookies
+playwright-cli eval "document.title"   # run JS in page
+playwright-cli pdf                    # save page as PDF
+```
+
+**Use for:** E2E testing, visual verification, form automation, web scraping.
+**NOT for:** API-only testing (use curl), static file reading.
+
+## codex exec
+
+Delegate tasks to Codex CLI (architecture design, parallel research, code review).
+
+```bash
+codex exec "Design a retry mechanism with exponential backoff for this module"
+```
+
+Good for: brainstorming, getting a second opinion, architecture decisions, reducing bikeshedding.
+
+## Memory Management
+
+Durable state files the agent can read and update:
+
+- `~/MEMORY.md` — stable facts, preferences, project context (edit existing entries, don't append duplicates)
+- `~/daily/YYYY-MM-DD/front-page.md` — today's work log, decisions, open loops
+- `~/daily/YYYY-MM-DD/articles/` — detailed write-ups for durable topics
+
+## AWS CLI
+
+Full AWS access via instance role (us-east-1). No credentials needed.
+
+```bash
+aws sts get-caller-identity
+aws s3 ls
+aws logs tail /aws/lambda/<name> --since 1h
+aws cloudformation describe-stacks --stack-name <name>
+```