macroclaw 0.0.0-dev

package/src/settings.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadSettings, newSessionId, saveSettings } from "./settings";
+
+const tmpDir = "/tmp/macroclaw-settings-test";
+
+afterEach(() => {
+  if (existsSync(tmpDir)) rmSync(tmpDir, { recursive: true });
+});
+
+describe("loadSettings", () => {
+  it("returns empty object when dir does not exist", () => {
+    expect(loadSettings(tmpDir)).toEqual({});
+  });
+
+  it("returns empty object when file does not exist", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    expect(loadSettings(tmpDir)).toEqual({});
+  });
+
+  it("reads settings from file", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "settings.json"), JSON.stringify({ sessionId: "abc-123" }));
+    expect(loadSettings(tmpDir)).toEqual({ sessionId: "abc-123" });
+  });
+
+  it("returns empty object when file is corrupt", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "settings.json"), "not json");
+    expect(loadSettings(tmpDir)).toEqual({});
+  });
+});
+
+describe("saveSettings", () => {
+  it("creates directory and writes file", () => {
+    saveSettings({ sessionId: "new-id" }, tmpDir);
+    const saved = loadSettings(tmpDir);
+    expect(saved).toEqual({ sessionId: "new-id" });
+  });
+
+  it("overwrites existing file", () => {
+    saveSettings({ sessionId: "first" }, tmpDir);
+    saveSettings({ sessionId: "second" }, tmpDir);
+    expect(loadSettings(tmpDir)).toEqual({ sessionId: "second" });
+  });
+});
+
+describe("newSessionId", () => {
+  it("returns a valid UUID", () => {
+    const id = newSessionId();
+    expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+    expect(newSessionId()).not.toBe(id);
+  });
+});

package/src/settings.ts

@@ -0,0 +1,36 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { z } from "zod/v4";
+import { createLogger } from "./logger";
+
+const log = createLogger("settings");
+
+const settingsSchema = z.object({
+  sessionId: z.string().optional(),
+});
+
+export type Settings = z.infer<typeof settingsSchema>;
+
+const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
+
+export function loadSettings(dir: string = defaultDir): Settings {
+  try {
+    const path = join(dir, "settings.json");
+    if (!existsSync(path)) return {};
+    const raw = readFileSync(path, "utf-8");
+    return settingsSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    log.warn({ err }, "Failed to load settings.json");
+    return {};
+  }
+}
+
+export function saveSettings(settings: Settings, dir: string = defaultDir): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`);
+}
+
+export function newSessionId(): string {
+  return randomUUID();
+}

package/src/stt.ts

@@ -0,0 +1,31 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import OpenAI from "openai";
+import { createLogger } from "./logger";
+
+const log = createLogger("stt");
+
+let client: OpenAI | undefined;
+
+function getClient(): OpenAI {
+  if (!client) client = new OpenAI();
+  return client;
+}
+
+export function isAvailable(): boolean {
+  return !!process.env.OPENAI_API_KEY;
+}
+
+export async function transcribe(filePath: string): Promise<string> {
+  const buffer = await readFile(filePath);
+  const file = new File([buffer], basename(filePath), { type: "audio/ogg" });
+
+  log.debug({ filePath }, "Transcribing audio");
+  const result = await getClient().audio.transcriptions.create({
+    model: "whisper-1",
+    file,
+  });
+
+  log.debug({ text: result.text }, "Transcription complete");
+  return result.text;
+}

package/src/telegram.test.ts

@@ -0,0 +1,283 @@
+import { describe, expect, it, mock } from "bun:test";
+import { existsSync } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { buildInlineKeyboard, createBot, downloadFile, sendFile, sendResponse } from "./telegram";
+
+// Mock bot API
+function mockBot() {
+  const calls: { chatId: string; text: string; opts?: any }[] = [];
+  return {
+    api: {
+      sendMessage: mock(async (chatId: string, text: string, opts?: any) => {
+        calls.push({ chatId, text, opts });
+      }),
+    },
+    calls,
+  } as any;
+}
+
+describe("createBot", () => {
+  it("returns a Grammy Bot instance", () => {
+    // Can't fully test without a real token, but verify it returns an object
+    const bot = createBot("test-token");
+    expect(bot).toBeDefined();
+    expect(bot.api).toBeDefined();
+  });
+});
+
+describe("sendResponse", () => {
+  it("sends short messages in a single call", async () => {
+    const bot = mockBot();
+    await sendResponse(bot, "123", "Hello");
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.calls[0]).toEqual({ chatId: "123", text: "Hello", opts: { parse_mode: "HTML" } });
+  });
+
+  it("sends messages at exactly 4096 chars in a single call", async () => {
+    const bot = mockBot();
+    const text = "x".repeat(4096);
+    await sendResponse(bot, "123", text);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+  });
+
+  it("splits long messages at line boundaries", async () => {
+    const bot = mockBot();
+    // Create text with lines that force a split
+    const line = "a".repeat(2000);
+    const text = `${line}\n${line}\n${line}`; // 6002 chars total
+    await sendResponse(bot, "123", text);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2);
+    // First chunk: line1 + \n + line2 = 4001 chars
+    expect(bot.calls[0].text).toBe(`${line}\n${line}`);
+    // Second chunk: line3 = 2000 chars
+    expect(bot.calls[1].text).toBe(line);
+  });
+
+  it("hard-splits single lines exceeding 4096 chars", async () => {
+    const bot = mockBot();
+    const longLine = "z".repeat(5000);
+    await sendResponse(bot, "123", longLine);
+    // Split into 4096 + 904
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2);
+    expect(bot.calls[0].text).toBe("z".repeat(4096));
+    expect(bot.calls[1].text).toBe("z".repeat(904));
+  });
+
+  it("handles long line preceded by a buffered chunk", async () => {
+    const bot = mockBot();
+    const shortLine = "short";
+    const longLine = "z".repeat(5000);
+    const text = `${shortLine}\n${longLine}`;
+    await sendResponse(bot, "123", text);
+    // 1: "short", 2: first 4096 of longLine, 3: remaining 904
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(3);
+    expect(bot.calls[0].text).toBe("short");
+    expect(bot.calls[1].text).toBe("z".repeat(4096));
+    expect(bot.calls[2].text).toBe("z".repeat(904));
+  });
+
+  it("handles line that exactly causes overflow", async () => {
+    const bot = mockBot();
+    const line1 = "a".repeat(4000);
+    const line2 = "b".repeat(200); // 4000 + 1 (newline) + 200 = 4201 > 4096
+    const text = `${line1}\n${line2}`;
+    await sendResponse(bot, "123", text);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2);
+    expect(bot.calls[0].text).toBe(line1);
+    expect(bot.calls[1].text).toBe(line2);
+  });
+
+  it("sends empty trailing chunk correctly", async () => {
+    const bot = mockBot();
+    await sendResponse(bot, "123", "hello\nworld");
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.calls[0].text).toBe("hello\nworld");
+  });
+
+  it("attaches buttons to a single message", async () => {
+    const bot = mockBot();
+    const buttons = ["Yes", "No"];
+    await sendResponse(bot, "123", "Choose:", buttons);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.calls[0].opts.reply_markup).toBeDefined();
+  });
+
+  it("attaches buttons to last chunk only when splitting", async () => {
+    const bot = mockBot();
+    const line = "a".repeat(2000);
+    const text = `${line}\n${line}\n${line}`;
+    const buttons = ["Ok"];
+    await sendResponse(bot, "123", text, buttons);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2);
+    // First chunk: no buttons
+    expect(bot.calls[0].opts.reply_markup).toBeUndefined();
+    // Last chunk: has buttons
+    expect(bot.calls[1].opts.reply_markup).toBeDefined();
+  });
+
+  it("sends without keyboard when buttons is empty", async () => {
+    const bot = mockBot();
+    await sendResponse(bot, "123", "Hello", []);
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.calls[0].opts.reply_markup).toBeUndefined();
+  });
+});
+
+describe("buildInlineKeyboard", () => {
+  it("builds keyboard with rows and buttons", () => {
+    const kb = buildInlineKeyboard(["A", "B", "C"]);
+    expect(kb).toBeDefined();
+    // InlineKeyboard from grammy — verify it's an object with inline_keyboard
+    expect(kb.inline_keyboard).toBeDefined();
+    expect(kb.inline_keyboard.length).toBe(3);
+    expect(kb.inline_keyboard[0].length).toBe(1);
+    const btn = kb.inline_keyboard[0][0] as any;
+    expect(btn.text).toBe("A");
+    expect(btn.callback_data).toBe("A");
+    expect((kb.inline_keyboard[2][0] as any).text).toBe("C");
+  });
+});
+
+describe("downloadFile", () => {
+  it("downloads file to /tmp/macroclaw/inbound/<uuid>/<name>", async () => {
+    const fileContent = new Uint8Array([1, 2, 3]);
+    const mockFetch = mock(() =>
+      Promise.resolve(new Response(fileContent, { status: 200 })),
+    );
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = mockFetch as any;
+
+    const bot = {
+      api: {
+        getFile: mock(async () => ({ file_path: "photos/file_42.jpg" })),
+      },
+    } as any;
+
+    const path = await downloadFile(bot, "file-id-123", "123:ABC", "photo.jpg");
+
+    expect(path).toContain("/tmp/macroclaw/inbound/");
+    expect(path).toEndWith("/photo.jpg");
+    expect(existsSync(path)).toBe(true);
+
+    const contents = await readFile(path);
+    expect(new Uint8Array(contents)).toEqual(fileContent);
+
+    const fetchUrl = (mockFetch as any).mock.calls[0][0];
+    expect(fetchUrl).toBe("https://api.telegram.org/file/bot123:ABC/photos/file_42.jpg");
+
+    // Cleanup
+    await rm(path, { force: true });
+    globalThis.fetch = origFetch;
+  });
+
+  it("uses file_path basename when no originalName given", async () => {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response("data", { status: 200 })),
+    ) as any;
+
+    const bot = {
+      api: {
+        getFile: mock(async () => ({ file_path: "documents/report.pdf" })),
+      },
+    } as any;
+
+    const path = await downloadFile(bot, "file-id", "token");
+    expect(path).toEndWith("/report.pdf");
+
+    await rm(path, { force: true });
+    globalThis.fetch = origFetch;
+  });
+
+  it("throws when Telegram returns no file_path", async () => {
+    const bot = {
+      api: { getFile: mock(async () => ({})) },
+    } as any;
+
+    expect(downloadFile(bot, "file-id", "token")).rejects.toThrow("no file_path");
+  });
+
+  it("throws when download fails", async () => {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response("", { status: 404 })),
+    ) as any;
+
+    const bot = {
+      api: { getFile: mock(async () => ({ file_path: "photos/x.jpg" })) },
+    } as any;
+
+    expect(downloadFile(bot, "file-id", "token")).rejects.toThrow("Download failed: 404");
+    globalThis.fetch = origFetch;
+  });
+});
+
+describe("sendFile", () => {
+  it("sends image extensions as photos", async () => {
+    const tmpFile = `/tmp/macroclaw-test-${Date.now()}.png`;
+    await Bun.write(tmpFile, "fake png");
+
+    const bot = {
+      api: {
+        sendPhoto: mock(async () => {}),
+        sendDocument: mock(async () => {}),
+      },
+    } as any;
+
+    await sendFile(bot, "123", tmpFile);
+    expect(bot.api.sendPhoto).toHaveBeenCalledTimes(1);
+    expect(bot.api.sendDocument).not.toHaveBeenCalled();
+
+    await rm(tmpFile, { force: true });
+  });
+
+  it("sends non-image extensions as documents", async () => {
+    const tmpFile = `/tmp/macroclaw-test-${Date.now()}.pdf`;
+    await Bun.write(tmpFile, "fake pdf");
+
+    const bot = {
+      api: {
+        sendPhoto: mock(async () => {}),
+        sendDocument: mock(async () => {}),
+      },
+    } as any;
+
+    await sendFile(bot, "123", tmpFile);
+    expect(bot.api.sendDocument).toHaveBeenCalledTimes(1);
+    expect(bot.api.sendPhoto).not.toHaveBeenCalled();
+
+    await rm(tmpFile, { force: true });
+  });
+
+  it("skips missing files without sending", async () => {
+    const bot = {
+      api: {
+        sendPhoto: mock(async () => {}),
+        sendDocument: mock(async () => {}),
+      },
+    } as any;
+
+    await sendFile(bot, "123", "/tmp/nonexistent-file-xyz.txt");
+    expect(bot.api.sendPhoto).not.toHaveBeenCalled();
+    expect(bot.api.sendDocument).not.toHaveBeenCalled();
+  });
+
+  for (const ext of [".jpg", ".jpeg", ".gif", ".webp"]) {
+    it(`treats ${ext} as image`, async () => {
+      const tmpFile = `/tmp/macroclaw-test-${Date.now()}${ext}`;
+      await Bun.write(tmpFile, "fake");
+
+      const bot = {
+        api: {
+          sendPhoto: mock(async () => {}),
+          sendDocument: mock(async () => {}),
+        },
+      } as any;
+
+      await sendFile(bot, "123", tmpFile);
+      expect(bot.api.sendPhoto).toHaveBeenCalledTimes(1);
+
+      await rm(tmpFile, { force: true });
+    });
+  }
+});

package/src/telegram.ts

@@ -0,0 +1,121 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Bot, InlineKeyboard, InputFile } from "grammy";
+import { createLogger } from "./logger";
+
+const log = createLogger("telegram");
+
+const MAX_LENGTH = 4096;
+const INBOUND_DIR = "/tmp/macroclaw/inbound";
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+
+export function createBot(token: string) {
+  return new Bot(token);
+}
+
+export function buildInlineKeyboard(buttons: string[]): InlineKeyboard {
+  const kb = new InlineKeyboard();
+  for (let i = 0; i < buttons.length; i++) {
+    if (i > 0) kb.row();
+    kb.text(buttons[i], buttons[i]);
+  }
+  return kb;
+}
+
+export async function sendResponse(
+  bot: Bot,
+  chatId: string,
+  text: string,
+  buttons?: string[],
+): Promise<void> {
+  const opts = { parse_mode: "HTML" as const };
+  const replyMarkup = buttons?.length ? buildInlineKeyboard(buttons) : undefined;
+
+  if (text.length <= MAX_LENGTH) {
+    await bot.api.sendMessage(chatId, text, { ...opts, reply_markup: replyMarkup });
+    return;
+  }
+
+  // Split at line boundaries into chunks <= MAX_LENGTH
+  const lines = text.split("\n");
+  const chunks: string[] = [];
+  let chunk = "";
+
+  for (const line of lines) {
+    if (line.length > MAX_LENGTH) {
+      if (chunk) {
+        chunks.push(chunk);
+        chunk = "";
+      }
+      for (let i = 0; i < line.length; i += MAX_LENGTH) {
+        chunks.push(line.slice(i, i + MAX_LENGTH));
+      }
+      continue;
+    }
+
+    const candidate = chunk ? `${chunk}\n${line}` : line;
+    if (candidate.length > MAX_LENGTH) {
+      chunks.push(chunk);
+      chunk = line;
+    } else {
+      chunk = candidate;
+    }
+  }
+
+  if (chunk) {
+    chunks.push(chunk);
+  }
+
+  // Send all chunks; attach buttons to the last one only
+  for (let i = 0; i < chunks.length; i++) {
+    const isLast = i === chunks.length - 1;
+    await bot.api.sendMessage(chatId, chunks[i], { ...opts, reply_markup: isLast ? replyMarkup : undefined });
+  }
+}
+
+export async function downloadFile(
+  bot: Bot,
+  fileId: string,
+  token: string,
+  originalName?: string,
+): Promise<string> {
+  const file = await bot.api.getFile(fileId);
+  const filePath = file.file_path;
+  if (!filePath) throw new Error("Telegram returned no file_path");
+
+  const url = `https://api.telegram.org/file/bot${token}/${filePath}`;
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Download failed: ${response.status}`);
+
+  const dir = join(INBOUND_DIR, randomUUID());
+  await mkdir(dir, { recursive: true });
+  const name = originalName ?? filePath.split("/").pop() ?? "file";
+  const dest = join(dir, name);
+  await writeFile(dest, new Uint8Array(await response.arrayBuffer()));
+  return dest;
+}
+
+function extName(path: string): string {
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? "" : path.slice(dot).toLowerCase();
+}
+
+export async function sendFile(
+  bot: Bot,
+  chatId: string,
+  filePath: string,
+): Promise<void> {
+  if (!existsSync(filePath)) {
+    log.warn({ filePath }, "File not found, skipping");
+    return;
+  }
+
+  const ext = extName(filePath);
+  if (IMAGE_EXTENSIONS.has(ext)) {
+    await bot.api.sendPhoto(chatId, new InputFile(filePath));
+  } else {
+    await bot.api.sendDocument(chatId, new InputFile(filePath));
+  }
+}

package/src/test-setup.ts

@@ -0,0 +1 @@
+process.env.LOG_LEVEL = "silent";

package/workspace-template/.claude/hooks/pre-compact.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Context is about to be compacted. Before continuing, append any new facts, preferences, or decisions you learned in this session to today's daily log (memory/$(date +%Y-%m-%d).md)."

package/workspace-template/.claude/settings.json

@@ -0,0 +1,19 @@
+{
+  "autoMemoryEnabled": false,
+  "permissions": {
+    "defaultMode": "bypassPermissions"
+  },
+  "dangerouslySkipPermissions": true,
+  "hooks": {
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".claude/hooks/pre-compact.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/workspace-template/.claude/skills/add-cronjob/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: add-cronjob
+description: Add a new scheduled cron job. Use when the user wants to schedule a recurring prompt, add a periodic task, or set up automated messages.
+---
+
+Add a new cron job to `.macroclaw/cron.json` in this workspace.
+
+## Steps
+
+1. Read the current `.macroclaw/cron.json` file (create it if missing with `{"jobs": []}`)
+2. Ask the user what prompt to run and when (if not already specified)
+3. Build a standard cron expression for the schedule
+4. Append the new job to the `jobs` array
+5. Write the updated file
+6. Confirm what was added and when it will next run
+
+## cron.json format
+
+```json
+{
+  "jobs": [
+    {
+      "name": "morning-summary",
+      "cron": "0 9 * * *",
+      "prompt": "Give me a morning summary of my tasks"
+    },
+    {
+      "name": "email-check",
+      "cron": "*/30 * * * *",
+      "prompt": "Check if any important emails arrived",
+      "model": "haiku"
+    },
+    {
+      "name": "weekly-report",
+      "cron": "0 17 * * 5",
+      "prompt": "Generate a weekly report of completed tasks",
+      "recurring": false
+    }
+  ]
+}
+```
+
+## Job fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | yes | Short identifier for the job. Appears in the `[Tool: cron/<name>]` prefix so the agent knows which job triggered the prompt. Use kebab-case (e.g. `morning-summary`). |
+| `cron` | yes | Standard cron expression defining when the job runs. See reference below. |
+| `prompt` | yes | The message sent to Claude when the job fires. Write it as if you're typing a message in Telegram — the agent will receive and act on it. |
+| `recurring` | no | Whether the job repeats. Defaults to `true`. Set to `false` for one-shot jobs that should fire once and be automatically removed from cron.json. Good for reminders ("remind me to call the dentist tomorrow at 10") or one-time scheduled events ("send the weekly report this Friday"). |
+| `model` | no | Override the model for this specific job. Omit to use the default model (set via `MODEL` in `.env`), which is best for normal interactive tasks. Use `haiku` for cheap/fast routine checks (email polling, status pings). Use `opus` only when the task genuinely needs deeper reasoning. |
+
+## Cron expression reference
+
+```
+┌───────── minute (0-59)
+│ ┌─────── hour (0-23)
+│ │ ┌───── day of month (1-31)
+│ │ │ ┌─── month (1-12)
+│ │ │ │ ┌─ day of week (0-7, 0 and 7 = Sunday)
+│ │ │ │ │
+* * * * *
+```
+
+Common patterns:
+- `0 9 * * *` — daily at 9:00
+- `0 9 * * 1-5` — weekdays at 9:00
+- `*/30 * * * *` — every 30 minutes
+- `0 */2 * * *` — every 2 hours
+- `0 9,18 * * *` — at 9:00 and 18:00
+
+## Notes
+
+- Changes are hot-reloaded — no restart needed
+- File location: `<workspace>/.macroclaw/cron.json`
+- Prompts are injected into the conversation with a `[Tool: cron/<name>]` prefix
+- One-shot jobs (`recurring: false`) are cleaned up automatically after firing

package/workspace-template/.macroclaw/cron.json

@@ -0,0 +1,16 @@
+{
+  "jobs": [
+    {
+      "name": "memory-capture",
+      "cron": "0 */4 * * *",
+      "model": "haiku",
+      "prompt": "Append today's noteworthy events to memory/YYYY-MM-DD.md (create the file and directory if needed). Add a ## HH:MM heading with bullet points underneath. Capture: decisions made, facts learned, user preferences expressed, tasks completed or started, problems solved. Be factual and concise — one line per item. If the file already exists, APPEND only — never overwrite. If nothing meaningful happened since the last entry, respond silently."
+    },
+    {
+      "name": "memory-consolidate",
+      "cron": "0 3 * * *",
+      "model": "opus",
+      "prompt": "Read daily logs in memory/ from the past 3 days. Distill durable knowledge into MEMORY.md: confirmed facts, recurring patterns, stable preferences, key decisions, and important context. Remove entries from MEMORY.md that are outdated or contradicted by recent logs. Keep MEMORY.md concise and organized by topic (not chronologically). Do not duplicate entries. If daily logs contain new personal facts about the user (preferences, routines, family, work, interests), update USER.md accordingly. Respond silently."
+    }
+  ]
+}