feat: add /config chat config updates

src/auto-reply/commands-registry.ts

@@ -136,6 +136,13 @@ export const CHAT_COMMANDS: ChatCommandDefinition[] = (() => {
       description: "Show current status.",
       textAlias: "/status",
     }),
+    defineChatCommand({
+      key: "config",
+      nativeName: "config",
+      description: "Show or set config values.",
+      textAlias: "/config",
+      acceptsArgs: true,
+    }),
     defineChatCommand({
       key: "debug",
       nativeName: "debug",

src/auto-reply/reply/commands.ts

@@ -20,6 +20,17 @@ import {
   waitForEmbeddedPiRunEnd,
 } from "../../agents/pi-embedded.js";
 import type { ClawdbotConfig } from "../../config/config.js";
+import {
+  readConfigFileSnapshot,
+  validateConfigObject,
+  writeConfigFile,
+} from "../../config/config.js";
+import {
+  getConfigValueAtPath,
+  parseConfigPath,
+  setConfigValueAtPath,
+  unsetConfigValueAtPath,
+} from "../../config/config-paths.js";
 import {
   getConfigOverrides,
   resetConfigOverrides,
@@ -72,6 +83,7 @@ import type {
 } from "../thinking.js";
 import type { ReplyPayload } from "../types.js";
 import { isAbortTrigger, setAbortMemory } from "./abort.js";
+import { parseConfigCommand } from "./config-commands.js";
 import { parseDebugCommand } from "./debug-commands.js";
 import type { InlineDirectives } from "./directive-handling.js";
 import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
@@ -628,6 +640,124 @@ export async function handleCommands(params: {
     return { shouldContinue: false, reply };
   }
 
+  const configCommand = allowTextCommands
+    ? parseConfigCommand(command.commandBodyNormalized)
+    : null;
+  if (configCommand) {
+    if (!command.isAuthorizedSender) {
+      logVerbose(
+        `Ignoring /config from unauthorized sender: ${command.senderE164 || "<unknown>"}`,
+      );
+      return { shouldContinue: false };
+    }
+    if (configCommand.action === "error") {
+      return {
+        shouldContinue: false,
+        reply: { text: `⚠️ ${configCommand.message}` },
+      };
+    }
+    const snapshot = await readConfigFileSnapshot();
+    if (!snapshot.valid || !snapshot.parsed || typeof snapshot.parsed !== "object") {
+      return {
+        shouldContinue: false,
+        reply: { text: "⚠️ Config file is invalid; fix it before using /config." },
+      };
+    }
+    const parsedBase = structuredClone(
+      snapshot.parsed as Record<string, unknown>,
+    );
+
+    if (configCommand.action === "show") {
+      const pathRaw = configCommand.path?.trim();
+      if (pathRaw) {
+        const parsedPath = parseConfigPath(pathRaw);
+        if (!parsedPath.ok || !parsedPath.path) {
+          return {
+            shouldContinue: false,
+            reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+          };
+        }
+        const value = getConfigValueAtPath(parsedBase, parsedPath.path);
+        const rendered = JSON.stringify(value ?? null, null, 2);
+        return {
+          shouldContinue: false,
+          reply: {
+            text: `⚙️ Config ${pathRaw}:\n\`\`\`json\n${rendered}\n\`\`\``,
+          },
+        };
+      }
+      const json = JSON.stringify(parsedBase, null, 2);
+      return {
+        shouldContinue: false,
+        reply: { text: `⚙️ Config (raw):\n\`\`\`json\n${json}\n\`\`\`` },
+      };
+    }
+
+    if (configCommand.action === "unset") {
+      const parsedPath = parseConfigPath(configCommand.path);
+      if (!parsedPath.ok || !parsedPath.path) {
+        return {
+          shouldContinue: false,
+          reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+        };
+      }
+      const removed = unsetConfigValueAtPath(parsedBase, parsedPath.path);
+      if (!removed) {
+        return {
+          shouldContinue: false,
+          reply: { text: `⚙️ No config value found for ${configCommand.path}.` },
+        };
+      }
+      const validated = validateConfigObject(parsedBase);
+      if (!validated.ok) {
+        const issue = validated.issues[0];
+        return {
+          shouldContinue: false,
+          reply: {
+            text: `⚠️ Config invalid after unset (${issue.path}: ${issue.message}).`,
+          },
+        };
+      }
+      await writeConfigFile(validated.config);
+      return {
+        shouldContinue: false,
+        reply: { text: `⚙️ Config updated: ${configCommand.path} removed.` },
+      };
+    }
+
+    if (configCommand.action === "set") {
+      const parsedPath = parseConfigPath(configCommand.path);
+      if (!parsedPath.ok || !parsedPath.path) {
+        return {
+          shouldContinue: false,
+          reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+        };
+      }
+      setConfigValueAtPath(parsedBase, parsedPath.path, configCommand.value);
+      const validated = validateConfigObject(parsedBase);
+      if (!validated.ok) {
+        const issue = validated.issues[0];
+        return {
+          shouldContinue: false,
+          reply: {
+            text: `⚠️ Config invalid after set (${issue.path}: ${issue.message}).`,
+          },
+        };
+      }
+      await writeConfigFile(validated.config);
+      const valueLabel =
+        typeof configCommand.value === "string"
+          ? `"${configCommand.value}"`
+          : JSON.stringify(configCommand.value);
+      return {
+        shouldContinue: false,
+        reply: {
+          text: `⚙️ Config updated: ${configCommand.path}=${valueLabel ?? "null"}`,
+        },
+      };
+    }
+  }
+
   const debugCommand = allowTextCommands
     ? parseDebugCommand(command.commandBodyNormalized)
     : null;

src/auto-reply/reply/config-commands.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+
+import { parseConfigCommand } from "./config-commands.js";
+
+describe("parseConfigCommand", () => {
+  it("parses show/unset", () => {
+    expect(parseConfigCommand("/config")).toEqual({ action: "show" });
+    expect(parseConfigCommand("/config show")).toEqual({ action: "show", path: undefined });
+    expect(parseConfigCommand("/config show foo.bar")).toEqual({
+      action: "show",
+      path: "foo.bar",
+    });
+    expect(parseConfigCommand("/config unset foo.bar")).toEqual({
+      action: "unset",
+      path: "foo.bar",
+    });
+  });
+
+  it("parses set with JSON", () => {
+    const cmd = parseConfigCommand('/config set foo={"a":1}');
+    expect(cmd).toEqual({ action: "set", path: "foo", value: { a: 1 } });
+  });
+});

src/auto-reply/reply/config-commands.ts

@@ -0,0 +1,62 @@
+import { parseConfigValue } from "./config-value.js";
+
+export type ConfigCommand =
+  | { action: "show"; path?: string }
+  | { action: "set"; path: string; value: unknown }
+  | { action: "unset"; path: string }
+  | { action: "error"; message: string };
+
+export function parseConfigCommand(raw: string): ConfigCommand | null {
+  const trimmed = raw.trim();
+  if (!trimmed.toLowerCase().startsWith("/config")) return null;
+  const rest = trimmed.slice("/config".length).trim();
+  if (!rest) return { action: "show" };
+
+  const match = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+  if (!match) return { action: "error", message: "Invalid /config syntax." };
+  const action = match[1].toLowerCase();
+  const args = (match[2] ?? "").trim();
+
+  switch (action) {
+    case "show":
+      return { action: "show", path: args || undefined };
+    case "unset": {
+      if (!args)
+        return { action: "error", message: "Usage: /config unset path" };
+      return { action: "unset", path: args };
+    }
+    case "set": {
+      if (!args) {
+        return {
+          action: "error",
+          message: "Usage: /config set path=value",
+        };
+      }
+      const eqIndex = args.indexOf("=");
+      if (eqIndex <= 0) {
+        return {
+          action: "error",
+          message: "Usage: /config set path=value",
+        };
+      }
+      const path = args.slice(0, eqIndex).trim();
+      const rawValue = args.slice(eqIndex + 1);
+      if (!path) {
+        return {
+          action: "error",
+          message: "Usage: /config set path=value",
+        };
+      }
+      const parsed = parseConfigValue(rawValue);
+      if (parsed.error) {
+        return { action: "error", message: parsed.error };
+      }
+      return { action: "set", path, value: parsed.value };
+    }
+    default:
+      return {
+        action: "error",
+        message: "Usage: /config show|set|unset",
+      };
+  }
+}

src/auto-reply/reply/config-value.ts

@@ -0,0 +1,37 @@
+export function parseConfigValue(
+  raw: string,
+): { value?: unknown; error?: string } {
+  const trimmed = raw.trim();
+  if (!trimmed) return { error: "Missing value." };
+
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return { value: JSON.parse(trimmed) };
+    } catch (err) {
+      return { error: `Invalid JSON: ${String(err)}` };
+    }
+  }
+
+  if (trimmed === "true") return { value: true };
+  if (trimmed === "false") return { value: false };
+  if (trimmed === "null") return { value: null };
+
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (Number.isFinite(num)) return { value: num };
+  }
+
+  if (
+    (trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    try {
+      return { value: JSON.parse(trimmed) };
+    } catch {
+      const unquoted = trimmed.slice(1, -1);
+      return { value: unquoted };
+    }
+  }
+
+  return { value: trimmed };
+}

src/auto-reply/reply/debug-commands.ts

@@ -1,3 +1,5 @@
+import { parseConfigValue } from "./config-value.js";
+
 export type DebugCommand =
   | { action: "show" }
   | { action: "reset" }
@@ -5,42 +7,6 @@ export type DebugCommand =
   | { action: "unset"; path: string }
   | { action: "error"; message: string };
 
-function parseDebugValue(raw: string): { value?: unknown; error?: string } {
-  const trimmed = raw.trim();
-  if (!trimmed) return { error: "Missing value." };
-
-  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-    try {
-      return { value: JSON.parse(trimmed) };
-    } catch (err) {
-      return { error: `Invalid JSON: ${String(err)}` };
-    }
-  }
-
-  if (trimmed === "true") return { value: true };
-  if (trimmed === "false") return { value: false };
-  if (trimmed === "null") return { value: null };
-
-  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-    const num = Number(trimmed);
-    if (Number.isFinite(num)) return { value: num };
-  }
-
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-    (trimmed.startsWith("'") && trimmed.endsWith("'"))
-  ) {
-    try {
-      return { value: JSON.parse(trimmed) };
-    } catch {
-      const unquoted = trimmed.slice(1, -1);
-      return { value: unquoted };
-    }
-  }
-
-  return { value: trimmed };
-}
-
 export function parseDebugCommand(raw: string): DebugCommand | null {
   const trimmed = raw.trim();
   if (!trimmed.toLowerCase().startsWith("/debug")) return null;
@@ -84,7 +50,7 @@ export function parseDebugCommand(raw: string): DebugCommand | null {
           message: "Usage: /debug set path=value",
         };
       }
-      const parsed = parseDebugValue(rawValue);
+      const parsed = parseConfigValue(rawValue);
       if (parsed.error) {
         return { action: "error", message: parsed.error };
       }

src/auto-reply/status.ts

@@ -360,7 +360,7 @@ export function buildHelpMessage(): string {
   return [
     "ℹ️ Help",
     "Shortcuts: /new reset | /compact [instructions] | /restart relink (if enabled)",
-    "Options: /think <level> | /verbose on|off | /reasoning on|off | /elevated on|off | /model <id> | /cost on|off | /debug show",
+    "Options: /think <level> | /verbose on|off | /reasoning on|off | /elevated on|off | /model <id> | /cost on|off | /config show | /debug show",
     "More: /commands for all slash commands",
   ].join("\n");
 }