@shadowob/connector 1.1.3-dev.261 → 1.1.3-dev.281

package/README.md

@@ -26,6 +26,14 @@ npx @shadowob/connector@latest connect \
 
 Use `--dry-run` to preview writes and commands. Use `--json` with `plan` when embedding the plan in another tool.
 
+`connect` merges existing configuration instead of replacing it:
+
+- OpenClaw JSON defaults to `~/.shadowob/openclaw.json` or `--openclaw-config`.
+- Hermes updates `~/.hermes/.env` and merges `~/.hermes/config.yaml`.
+- cc-connect merges the ShadowOB platform into `~/.cc-connect/config.toml`.
+
+Existing model providers, plugins, projects, platforms, and unrelated keys are preserved.
+
 ## OpenClaw
 
 ```bash
@@ -57,7 +65,7 @@ npx @shadowob/connector@latest connect \
 
 The Hermes plugin is bundled in `hermes-shadowob-plugin/`. The connector copies it to `~/.hermes/plugins/shadowob`, writes the Shadow token/base URL, and enables the plugin.
 
-Hermes does not need `agentId` or `channelId` in the setup command. The plugin calls `/api/auth/me` to resolve the Buddy agent id, then `/api/agents/:id/config` to receive channel access policy dynamically, matching the OpenClaw plugin behavior.
+Hermes does not need `agentId` or `channelId` in the setup command. The plugin calls `/api/auth/me` to resolve the Buddy agent id, then `/api/agents/:id/config` to receive channel access policy dynamically, matching the OpenClaw plugin behavior. If no channel is available yet, Hermes stays online and waits for a DM, server join, channel membership, or policy update. By default it creates/uses the DM with the Buddy owner as the home channel.
 
 Manual config shape:
 
@@ -148,7 +156,7 @@ pnpm -C packages/connector build
 uv run --project .tmp/hermes-agent --with pytest python -m pytest packages/connector/hermes-shadowob-plugin/tests
 ```
 
-The tests cover plan generation for OpenClaw, Hermes, and cc-connect, and assert that Hermes setup no longer emits static `agentId` or `channelId` arguments.
+The tests cover plan generation, config merging for OpenClaw/Hermes/cc-connect, and Hermes dynamic channel behavior without static `agentId` or `channelId` arguments.
 
 ## Capability Coverage
 

package/dist/cli.js

@@ -7,6 +7,182 @@ import { homedir } from "os";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 
+// src/config-writers.ts
+import { parse as parseDotenv } from "dotenv";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var SHADOW_ENV_VALUES = {
+  SHADOW_ALLOW_ALL_USERS: "true",
+  SHADOW_HEARTBEAT_INTERVAL_SECONDS: "30",
+  SHADOW_SLASH_COMMANDS_JSON: "[]"
+};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? { ...value } : {};
+}
+function uniqueStrings(values, required) {
+  return [
+    .../* @__PURE__ */ new Set([...values.filter((value) => typeof value === "string"), required])
+  ];
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+function quoteEnv(value) {
+  return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function normalizeJsonRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = JSON.parse(existing);
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a JSON object`);
+  }
+  return { ...parsed };
+}
+function parseYamlRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = parseYaml(existing);
+  if (parsed == null) return {};
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a YAML object`);
+  }
+  return { ...parsed };
+}
+function parseTomlRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = parseToml(existing);
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a TOML table`);
+  }
+  return parsed;
+}
+function mergeEnvContent(existing, values) {
+  parseDotenv(existing);
+  const updates = {
+    SHADOW_BASE_URL: values.serverUrl,
+    SHADOW_TOKEN: values.token,
+    ...SHADOW_ENV_VALUES
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
+  const next = [];
+  for (const line of lines) {
+    const match = line.match(/^(\s*(?:export\s+)?)((?:[A-Za-z_][A-Za-z0-9_]*))\s*=/);
+    const key = match?.[2];
+    if (!key || !(key in updates)) {
+      next.push(line);
+      continue;
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    next.push(`${match[1] ?? ""}${key}=${quoteEnv(updates[key] ?? "")}`);
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    if (!seen.has(key)) next.push(`${key}=${quoteEnv(value)}`);
+  }
+  while (next.length > 0 && next[next.length - 1] === "") next.pop();
+  return ensureTrailingNewline(next.join("\n"));
+}
+function mergeOpenClawConfigContent(existing, values) {
+  const root = normalizeJsonRoot(existing, "OpenClaw");
+  const channels = asRecord(root.channels);
+  const legacyShadow = asRecord(channels["openclaw-shadowob"]);
+  const shadow = asRecord(channels.shadowob);
+  channels.shadowob = {
+    ...legacyShadow,
+    ...shadow,
+    token: values.token,
+    serverUrl: values.serverUrl
+  };
+  delete channels["openclaw-shadowob"];
+  root.channels = channels;
+  const plugins = asRecord(root.plugins);
+  plugins.enabled = plugins.enabled ?? true;
+  plugins.allow = uniqueStrings(
+    Array.isArray(plugins.allow) ? plugins.allow : [],
+    "openclaw-shadowob"
+  );
+  const entries = asRecord(plugins.entries);
+  entries["openclaw-shadowob"] = {
+    ...asRecord(entries["openclaw-shadowob"]),
+    enabled: true
+  };
+  plugins.entries = entries;
+  root.plugins = plugins;
+  return ensureTrailingNewline(JSON.stringify(root, null, 2));
+}
+function mergeHermesConfigContent(existing, values) {
+  const root = parseYamlRoot(existing, "Hermes");
+  const plugins = asRecord(root.plugins);
+  plugins.enabled = uniqueStrings(Array.isArray(plugins.enabled) ? plugins.enabled : [], "shadowob");
+  root.plugins = plugins;
+  const platforms = asRecord(root.platforms);
+  const shadowob = asRecord(platforms.shadowob);
+  const extra = asRecord(shadowob.extra);
+  platforms.shadowob = {
+    ...shadowob,
+    enabled: true,
+    token: values.token,
+    extra: {
+      mention_only: false,
+      rest_only: false,
+      catchup_minutes: 0,
+      download_media: true,
+      slash_commands: [],
+      ...extra,
+      base_url: values.serverUrl
+    }
+  };
+  root.platforms = platforms;
+  return ensureTrailingNewline(stringifyYaml(root));
+}
+function asTomlTable(value) {
+  return isRecord(value) && !Array.isArray(value) ? { ...value } : {};
+}
+function tomlArray(value) {
+  if (!Array.isArray(value)) return [];
+  const tables = [];
+  for (const item of value) {
+    if (isRecord(item)) tables.push({ ...item });
+  }
+  return tables;
+}
+function mergeCcConnectConfigContent(existing, values) {
+  const root = parseTomlRoot(existing, "cc-connect");
+  const projects = tomlArray(root.projects);
+  let project = projects.find((item) => item.name === values.projectName) ?? projects.find((item) => item.work_dir === values.workDir);
+  if (!project) {
+    project = {};
+    projects.push(project);
+  }
+  project.name = values.projectName;
+  project.work_dir = values.workDir;
+  project.agent_type = values.agentType;
+  const platforms = tomlArray(project.platforms);
+  let shadowPlatform = platforms.find((item) => item.type === "shadowob");
+  if (!shadowPlatform) {
+    shadowPlatform = {};
+    platforms.push(shadowPlatform);
+  }
+  const options = asTomlTable(shadowPlatform.options);
+  shadowPlatform.type = "shadowob";
+  shadowPlatform.options = {
+    allow_from: "*",
+    listen_dms: true,
+    share_session_in_channel: false,
+    progress_style: "compact",
+    ...options,
+    token: values.token,
+    server_url: values.serverUrl
+  };
+  project.platforms = platforms;
+  root.projects = projects;
+  return ensureTrailingNewline(stringifyToml(root));
+}
+
 // src/index.ts
 var DEFAULT_SERVER_URL = "https://shadowob.com";
 var DEFAULT_WORK_DIR = ".";
@@ -286,6 +462,7 @@ function usage() {
     "  shadowob-connector connect --target <openclaw|hermes|cc-connect> --server-url <url> --token <token>",
     "",
     "Options:",
+    "  --openclaw-config <path> OpenClaw JSON config, default $OPENCLAW_CONFIG or ~/.shadowob/openclaw.json",
     "  --hermes-home <path>    Hermes config directory, default $HERMES_HOME or ~/.hermes",
     "  --work-dir <path>       cc-connect project work directory",
     "  --project-name <name>   cc-connect project name",
@@ -316,6 +493,7 @@ function parseArgs(args) {
     target,
     serverUrl: readOption(optionArgs, "--server-url") ?? "https://shadowob.com",
     token: readOption(optionArgs, "--token") ?? "",
+    openclawConfig: readOption(optionArgs, "--openclaw-config"),
     hermesHome: readOption(optionArgs, "--hermes-home"),
     workDir: readOption(optionArgs, "--work-dir"),
     projectName: readOption(optionArgs, "--project-name"),
@@ -363,25 +541,19 @@ function writeFile(path, content, dryRun) {
   writeFileSync(path, content.endsWith("\n") ? content : `${content}
 `);
 }
-function upsertManagedBlock(path, name, content, dryRun) {
-  const begin = `# BEGIN ShadowOB ${name}`;
-  const end = `# END ShadowOB ${name}`;
-  const block = `${begin}
-${content}
-${end}`;
-  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
-  const pattern = new RegExp(
-    `${begin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
-  );
-  const next = existing.match(pattern) ? existing.replace(pattern, block) : [existing.trimEnd(), block].filter(Boolean).join("\n\n");
-  writeFile(path, next, dryRun);
-}
 function packageRoot() {
   return resolve(dirname(fileURLToPath(import.meta.url)), "..");
 }
 function expandHome(value) {
   return value.startsWith("~/") ? resolve(homedir(), value.slice(2)) : resolve(value);
 }
+function readExisting(path) {
+  return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+function normalizeServerUrl2(value) {
+  const trimmed = value.trim() || "https://shadowob.com";
+  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed.replace(/\/$/, "");
+}
 function hermesPluginSource() {
   const candidates = [
     resolve(packageRoot(), "hermes-shadowob-plugin"),
@@ -393,9 +565,21 @@ function hermesPluginSource() {
 }
 function applyOpenClaw(options) {
   const plan = createConnectorPlan(options);
-  for (const step of plan.commands) {
-    console.log(`Applying: ${step.label}`);
-    runShell(step.command, options.dryRun);
+  const configPath = expandHome(
+    options.openclawConfig ?? process.env.OPENCLAW_CONFIG ?? "~/.shadowob/openclaw.json"
+  );
+  console.log("Applying: Install plugin");
+  runShell("openclaw plugins install @shadowob/openclaw-shadowob", options.dryRun);
+  console.log(`Applying: Merge OpenClaw config ${configPath}`);
+  const next = mergeOpenClawConfigContent(readExisting(configPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(configPath, next, options.dryRun);
+  const restart = plan.commands.find((step) => step.label === "Restart gateway");
+  if (restart) {
+    console.log(`Applying: ${restart.label}`);
+    runShell(restart.command, options.dryRun);
   }
 }
 function applyHermes(options) {
@@ -404,23 +588,24 @@ function applyHermes(options) {
   const pluginTarget = resolve(hermesDir, "plugins/shadowob");
   const envPath = resolve(hermesDir, ".env");
   const configPath = resolve(hermesDir, "config.yaml");
-  const generatedConfigPath = resolve(hermesDir, "config.shadowob.yaml");
   const envBlock = plan.configBlocks.find((block) => block.label === "~/.hermes/.env");
-  const yamlBlock = plan.configBlocks.find((block) => block.label === "~/.hermes/config.yaml");
-  if (!envBlock || !yamlBlock) throw new Error("Hermes plan is missing config blocks");
+  if (!envBlock) throw new Error("Hermes plan is missing config blocks");
   if (options.dryRun) {
     console.log(`[dry-run] copy ${hermesPluginSource()} -> ${pluginTarget}`);
   } else {
     mkdirSync(resolve(hermesDir, "plugins"), { recursive: true });
     cpSync(hermesPluginSource(), pluginTarget, { recursive: true, force: true });
   }
-  upsertManagedBlock(envPath, "Hermes ShadowOB", envBlock.content, options.dryRun);
-  if (!existsSync(configPath) || options.force) {
-    writeFile(configPath, yamlBlock.content, options.dryRun);
-  } else {
-    writeFile(generatedConfigPath, yamlBlock.content, options.dryRun);
-    console.log(`Existing Hermes config kept. Generated ShadowOB config: ${generatedConfigPath}`);
-  }
+  const nextEnv = options.force ? envBlock.content : mergeEnvContent(readExisting(envPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(envPath, nextEnv, options.dryRun);
+  const nextConfig = mergeHermesConfigContent(options.force ? "" : readExisting(configPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(configPath, nextConfig, options.dryRun);
   if (options.install) {
     runShell(
       `python -m pip install -r "${resolve(pluginTarget, "requirements.txt")}"`,
@@ -437,13 +622,14 @@ function applyCcConnect(options) {
   const configBlock = plan.configBlocks.find((block) => block.label === "~/.cc-connect/config.toml");
   if (!configBlock) throw new Error("cc-connect plan is missing config block");
   const configPath = resolve(homedir(), ".cc-connect/config.toml");
-  const generatedPath = resolve(homedir(), ".cc-connect/config.shadowob.toml");
-  if (!existsSync(configPath) || options.force) {
-    writeFile(configPath, configBlock.content, options.dryRun);
-  } else {
-    writeFile(generatedPath, configBlock.content, options.dryRun);
-    console.log(`Existing cc-connect config kept. Generated ShadowOB config: ${generatedPath}`);
-  }
+  const nextConfig = options.force ? configBlock.content : mergeCcConnectConfigContent(readExisting(configPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl),
+    projectName: options.projectName?.trim() || "shadow-buddy",
+    workDir: options.workDir?.trim() || ".",
+    agentType: options.agentType?.trim() || "codex"
+  });
+  writeFile(configPath, nextConfig, options.dryRun);
   if (options.install) {
     runShell("npm install -g cc-connect", options.dryRun);
   }

package/hermes-shadowob-plugin/README.md

@@ -150,8 +150,8 @@ This iteration fixes issues found during static review against the uploaded Shad
 - Fixed REST polling shutdown condition so the polling loop stops when the adapter is disconnected.
 - Fixed `env_enablement_fn` to return a flat seed dict, because Hermes merges all non-`home_channel` keys directly into `PlatformConfig.extra`.
 - Changed env auto-enable and connector setup to require only Shadow endpoint/token; Buddy id and channel policy are now resolved dynamically from Shadow.
-- Added dynamic handling for `channel:member-added` and `channel:member-removed` events.
-- Added dynamic handling for `server:joined` and `agent:policy-changed` events.
+- Added OpenClaw-aligned dynamic handling for `channel:member-added`, `channel:member-removed`, `server:joined`, and `agent:policy-changed` events.
+- Changed empty-channel startup from fatal to tolerant waiting. The adapter stays online, refreshes channel policy periodically, and uses the owner DM as the default home channel when available.
 - Updated standalone media delivery to support local paths, `MEDIA:` refs, relative paths, Shadow private URLs and remote URLs through the SDK helper.
 
 ## Known limits in this first version

package/hermes-shadowob-plugin/adapter.py

@@ -465,6 +465,13 @@ def _remote_listen_channel_entries(
     return entries
 
 
+def _owner_id_from_remote_config(remote_config: dict[str, Any] | None) -> str | None:
+    if not isinstance(remote_config, dict):
+        return None
+    owner_id = str(remote_config.get("ownerId") or remote_config.get("owner_id") or "").strip()
+    return owner_id or None
+
+
 class ShadowOBAdapter(BasePlatformAdapter):
     """Hermes ``BasePlatformAdapter`` implementation for Shadow."""
 
@@ -479,6 +486,7 @@ class ShadowOBAdapter(BasePlatformAdapter):
         self.socket: ShadowSocketClient | None = None
         self._poll_task: asyncio.Task | None = None
         self._heartbeat_task: asyncio.Task | None = None
+        self._channel_refresh_task: asyncio.Task | None = None
         self._channel_ids: list[str] = _channel_ids_from_config(config)
         self._configured_channel_ids: set[str] = set(self._channel_ids)
         self._remote_channel_ids: set[str] = set()
@@ -532,26 +540,26 @@ class ShadowOBAdapter(BasePlatformAdapter):
             await self.client.open()
             await self._load_identity()
             await self._register_slash_commands()
-            await self._start_heartbeat()
             await self._resolve_channels()
             if not self._channel_ids:
-                self._set_fatal_error(
-                    "config_missing",
-                    "No Shadow channels are available for this Buddy token. Add the Buddy to a server/channel, open a DM, or verify the remote agent policy.",
-                    retryable=False,
+                logger.warning(
+                    "[Shadow] No channels are available yet for this Buddy token. "
+                    "Waiting for the Buddy to be added to a channel or DM.",
                 )
-                return False
 
-            if self._rest_only:
-                await self._start_polling()
-            else:
+            use_polling = self._rest_only
+            if not self._rest_only:
                 try:
                     await self._start_socket()
                 except Exception as exc:
                     logger.warning("[Shadow] Socket.IO connection failed, falling back to REST polling: %s", exc)
-                    await self._start_polling()
+                    use_polling = True
 
             self._mark_connected()
+            if use_polling:
+                await self._start_polling()
+            await self._start_heartbeat()
+            await self._start_channel_refresh()
             logger.info("[Shadow] Connected to %s; channels=%s", self.base_url, ",".join(self._channel_ids))
             return True
         except Exception as exc:
@@ -573,6 +581,13 @@ class ShadowOBAdapter(BasePlatformAdapter):
             except asyncio.CancelledError:
                 pass
         self._heartbeat_task = None
+        if self._channel_refresh_task is not None and not self._channel_refresh_task.done():
+            self._channel_refresh_task.cancel()
+            try:
+                await self._channel_refresh_task
+            except asyncio.CancelledError:
+                pass
+        self._channel_refresh_task = None
         if self._poll_task is not None and not self._poll_task.done():
             self._poll_task.cancel()
             try:
@@ -909,19 +924,47 @@ class ShadowOBAdapter(BasePlatformAdapter):
         self._remote_channel_ids = new_remote_ids
         logger.info("[Shadow] Refreshed remote config for agent %s; channels=%s", self._agent_id, len(new_remote_ids))
 
-        if sync_socket and self.socket is not None:
-            next_channel_ids = set(self._channel_ids)
-            for channel_id in old_channel_ids - next_channel_ids:
-                try:
-                    await self.socket.leave_channel(channel_id)
-                except Exception:
-                    pass
-            for channel_id in next_channel_ids - old_channel_ids:
-                try:
-                    ack = await self.socket.join_channel(channel_id)
-                    logger.info("[Shadow] Joined channel %s after config refresh ack=%s", channel_id, ack)
-                except Exception as exc:
-                    logger.warning("[Shadow] Failed to join refreshed channel %s: %s", channel_id, exc)
+        if sync_socket:
+            await self._sync_socket_channels(old_channel_ids)
+
+    async def _sync_socket_channels(self, old_channel_ids: set[str]) -> None:
+        if self.socket is None:
+            return
+        next_channel_ids = set(self._channel_ids)
+        for channel_id in old_channel_ids - next_channel_ids:
+            try:
+                await self.socket.leave_channel(channel_id)
+            except Exception:
+                pass
+        for channel_id in next_channel_ids - old_channel_ids:
+            try:
+                ack = await self.socket.join_channel(channel_id)
+                logger.info("[Shadow] Joined channel %s after config refresh ack=%s", channel_id, ack)
+            except Exception as exc:
+                logger.warning("[Shadow] Failed to join refreshed channel %s: %s", channel_id, exc)
+
+    async def _ensure_owner_dm_home_channel(self) -> None:
+        if self.client is None:
+            return
+        owner_id = _owner_id_from_remote_config(self._remote_config)
+        if not owner_id or owner_id == self._bot_user_id:
+            return
+        try:
+            channel = await self.client.create_direct_channel(owner_id)
+        except Exception as exc:
+            logger.debug("[Shadow] Owner DM home channel is not available yet: %s", exc)
+            return
+        channel_id = str(channel.get("id") or "").strip()
+        if not channel_id:
+            return
+        self._channel_cache[channel_id] = {
+            **channel,
+            "kind": channel.get("kind") or channel.get("type") or "dm",
+        }
+        self._channel_policies.setdefault(channel_id, _default_policy_from_remote_config(self._remote_config))
+        if channel_id not in self._channel_ids:
+            self._channel_ids.append(channel_id)
+            logger.info("[Shadow] Using owner DM %s as the default home channel", channel_id)
 
     async def _register_slash_commands(self) -> None:
         if self.client is None or not self._agent_id or not self._slash_commands:
@@ -952,6 +995,26 @@ class ShadowOBAdapter(BasePlatformAdapter):
         except Exception as exc:
             logger.debug("[Shadow] heartbeat failed for agent %s: %s", self._agent_id, exc)
 
+    async def _start_channel_refresh(self) -> None:
+        if self._channel_refresh_task is None or self._channel_refresh_task.done():
+            self._channel_refresh_task = asyncio.create_task(
+                self._channel_refresh_loop(),
+                name="shadowob-channel-refresh",
+            )
+
+    async def _channel_refresh_loop(self) -> None:
+        interval = max(10.0, min(60.0, self._heartbeat_interval))
+        while self._running and not self.has_fatal_error:
+            await asyncio.sleep(interval)
+            try:
+                await self._resolve_channels(sync_socket=True)
+                if not self._channel_ids:
+                    logger.debug("[Shadow] Still waiting for a channel or owner DM")
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                logger.debug("[Shadow] Channel refresh failed: %s", exc)
+
     async def _send_slash_interactive_prompt(
         self,
         match: tuple[dict[str, Any], str, str],
@@ -986,9 +1049,10 @@ class ShadowOBAdapter(BasePlatformAdapter):
         logger.info("[Shadow] Sent interactive prompt for slash command /%s", name)
         return True
 
-    async def _resolve_channels(self) -> None:
+    async def _resolve_channels(self, *, sync_socket: bool = False) -> None:
         if self.client is None:
             return
+        old_channel_ids = set(self._channel_ids)
         if self._agent_id:
             try:
                 await self._refresh_remote_config()
@@ -1044,6 +1108,8 @@ class ShadowOBAdapter(BasePlatformAdapter):
             except Exception as exc:
                 logger.debug("[Shadow] Failed to list direct channels: %s", exc)
 
+        await self._ensure_owner_dm_home_channel()
+
         # Best-effort metadata cache for explicitly configured channels.
         for channel_id in list(self._channel_ids):
             if channel_id in self._channel_cache:
@@ -1053,6 +1119,9 @@ class ShadowOBAdapter(BasePlatformAdapter):
             except Exception:
                 self._channel_cache[channel_id] = {"id": channel_id, "name": channel_id, "kind": "channel"}
 
+        if sync_socket:
+            await self._sync_socket_channels(old_channel_ids)
+
     async def _start_socket(self) -> None:
         self.socket = ShadowSocketClient(self.base_url, self.token, transports=self._transports, logger=logger)
         self.socket.on("connect", self._on_socket_connect)
@@ -1070,13 +1139,27 @@ class ShadowOBAdapter(BasePlatformAdapter):
         self.socket.on("server:joined", self._on_server_joined)
         self.socket.on("agent:policy-changed", self._on_agent_policy_changed)
         await self.socket.connect()
-        await self.socket.update_presence("online")
-        for channel_id in self._channel_ids:
-            ack = await self.socket.join_channel(channel_id)
-            logger.info("[Shadow] Joined channel %s ack=%s", channel_id, ack)
+        await self._join_current_socket_channels()
         if self._catchup_minutes > 0:
             await self._catchup_recent_messages()
 
+    async def _join_current_socket_channels(self) -> None:
+        if self.socket is None:
+            return
+        try:
+            await self.socket.update_presence("online")
+        except Exception as exc:
+            logger.debug("[Shadow] Failed to update socket presence: %s", exc)
+        if not self._channel_ids:
+            logger.info("[Shadow] Socket connected with no channels yet; waiting for channel membership events")
+            return
+        for channel_id in list(self._channel_ids):
+            try:
+                ack = await self.socket.join_channel(channel_id)
+                logger.info("[Shadow] Joined channel %s ack=%s", channel_id, ack)
+            except Exception as exc:
+                logger.warning("[Shadow] Failed to join channel %s: %s", channel_id, exc)
+
     async def _start_polling(self) -> None:
         if self._catchup_minutes > 0:
             await self._catchup_recent_messages()
@@ -1142,6 +1225,7 @@ class ShadowOBAdapter(BasePlatformAdapter):
 
     async def _on_socket_connect(self) -> None:
         logger.info("[Shadow] Socket connected")
+        await self._join_current_socket_channels()
 
     async def _on_socket_disconnect(self, reason: str | None = None) -> None:
         logger.info("[Shadow] Socket disconnected: %s", reason)
@@ -1163,6 +1247,11 @@ class ShadowOBAdapter(BasePlatformAdapter):
         channel_id = str(payload.get("channelId") or payload.get("channel_id") or "").strip()
         if not channel_id:
             return
+        old_channel_ids = set(self._channel_ids)
+        try:
+            await self._resolve_channels(sync_socket=False)
+        except Exception as exc:
+            logger.warning("[Shadow] Failed to refresh config after channel member add: %s", exc)
         if channel_id not in self._channel_ids:
             self._channel_ids.append(channel_id)
         if self.client is not None:
@@ -1170,10 +1259,13 @@ class ShadowOBAdapter(BasePlatformAdapter):
                 self._channel_cache[channel_id] = await self.client.get_channel(channel_id)
             except Exception:
                 self._channel_cache[channel_id] = {"id": channel_id, "name": channel_id, "kind": "channel"}
+        self._channel_policies.setdefault(
+            channel_id,
+            _default_policy_from_remote_config(self._remote_config),
+        )
         if self.socket is not None:
             try:
-                ack = await self.socket.join_channel(channel_id)
-                logger.info("[Shadow] Joined newly added channel %s ack=%s", channel_id, ack)
+                await self._sync_socket_channels(old_channel_ids)
             except Exception as exc:
                 logger.warning("[Shadow] Failed to join newly added channel %s: %s", channel_id, exc)
         if self._catchup_minutes > 0:
@@ -1200,7 +1292,7 @@ class ShadowOBAdapter(BasePlatformAdapter):
         if payload_agent_id and self._agent_id and payload_agent_id != self._agent_id:
             return
         try:
-            await self._refresh_remote_config(sync_socket=True)
+            await self._resolve_channels(sync_socket=True)
         except Exception as exc:
             logger.warning("[Shadow] Failed to refresh remote config after server join: %s", exc)
 
@@ -1209,7 +1301,7 @@ class ShadowOBAdapter(BasePlatformAdapter):
         if payload_agent_id and self._agent_id and payload_agent_id != self._agent_id:
             return
         try:
-            await self._refresh_remote_config(sync_socket=True)
+            await self._resolve_channels(sync_socket=True)
         except Exception as exc:
             logger.warning("[Shadow] Failed to refresh remote config after policy change: %s", exc)
 

package/hermes-shadowob-plugin/shadow_sdk.py

@@ -231,6 +231,13 @@ class ShadowAsyncClient:
     async def list_direct_channels(self) -> list[JsonDict]:
         return await self.request("GET", "/api/channels/dm")
 
+    async def create_direct_channel(self, user_id: str) -> JsonDict:
+        return await self.request(
+            "POST",
+            "/api/channels/dm",
+            json_body={"userId": str(user_id)},
+        )
+
     async def get_channel(self, channel_id: str) -> JsonDict:
         return await self.request("GET", f"/api/channels/{quote(str(channel_id), safe='')}")
 

package/hermes-shadowob-plugin/tests/test_adapter_env.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 import sys
+import asyncio
 
 ROOT = Path(__file__).resolve().parents[1]
 if str(ROOT) not in sys.path:
@@ -83,6 +84,107 @@ def test_remote_config_entries_filter_listen_policy():
     assert entries[0][1]['serverId'] == 'server-1'
 
 
+def test_resolve_channels_creates_owner_dm_home_channel_when_empty():
+    class FakeClient:
+        async def get_agent_config(self, agent_id):
+            assert agent_id == 'agent-1'
+            return {
+                'agentId': 'agent-1',
+                'botUserId': 'bot-1',
+                'ownerId': 'owner-1',
+                'servers': [],
+            }
+
+        async def create_direct_channel(self, user_id):
+            assert user_id == 'owner-1'
+            return {'id': 'dm-owner', 'kind': 'dm', 'name': 'Owner DM'}
+
+    class FakeSocket:
+        def __init__(self):
+            self.joined = []
+
+        async def join_channel(self, channel_id):
+            self.joined.append(channel_id)
+            return {'ok': True}
+
+    instance = adapter.ShadowOBAdapter.__new__(adapter.ShadowOBAdapter)
+    instance.client = FakeClient()
+    instance.socket = FakeSocket()
+    instance._agent_id = 'agent-1'
+    instance._bot_user_id = 'bot-1'
+    instance._slash_commands = []
+    instance._channel_ids = []
+    instance._configured_channel_ids = set()
+    instance._remote_channel_ids = set()
+    instance._channel_policies = {}
+    instance._remote_config = None
+    instance._channel_cache = {}
+    instance._server_ids = []
+    instance._auto_discover = False
+
+    asyncio.run(instance._resolve_channels(sync_socket=True))
+
+    assert instance._channel_ids == ['dm-owner']
+    assert instance._channel_cache['dm-owner']['kind'] == 'dm'
+    assert instance.socket.joined == ['dm-owner']
+
+
+def test_member_added_refreshes_remote_config_and_joins_channel():
+    class FakeClient:
+        async def get_agent_config(self, agent_id):
+            assert agent_id == 'agent-1'
+            return {
+                'agentId': 'agent-1',
+                'botUserId': 'bot-1',
+                'servers': [
+                    {
+                        'id': 'server-1',
+                        'name': 'Server',
+                        'channels': [
+                            {
+                                'id': 'channel-1',
+                                'name': 'general',
+                                'policy': {'listen': True, 'reply': True},
+                            }
+                        ],
+                    }
+                ],
+            }
+
+        async def get_channel(self, channel_id):
+            return {'id': channel_id, 'kind': 'channel', 'name': 'general'}
+
+    class FakeSocket:
+        def __init__(self):
+            self.joined = []
+
+        async def join_channel(self, channel_id):
+            self.joined.append(channel_id)
+            return {'ok': True}
+
+    instance = adapter.ShadowOBAdapter.__new__(adapter.ShadowOBAdapter)
+    instance.client = FakeClient()
+    instance.socket = FakeSocket()
+    instance._agent_id = 'agent-1'
+    instance._bot_user_id = 'bot-1'
+    instance._slash_commands = []
+    instance._channel_ids = []
+    instance._configured_channel_ids = set()
+    instance._remote_channel_ids = set()
+    instance._channel_policies = {}
+    instance._remote_config = None
+    instance._channel_cache = {}
+    instance._server_ids = []
+    instance._auto_discover = False
+    instance._catchup_minutes = 0
+
+    asyncio.run(instance._on_channel_member_added({'channelId': 'channel-1'}))
+
+    assert instance._channel_ids == ['channel-1']
+    assert instance._channel_policies['channel-1']['reply'] is True
+    assert instance.socket.joined == ['channel-1']
+
+
 def test_slash_command_prompt_and_interactive_block():
     commands = [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadowob/connector",
-  "version": "1.1.3-dev.261",
+  "version": "1.1.3-dev.281",
   "description": "Shadow connector helpers for OpenClaw, Hermes Agent, and cc-connect",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,6 +47,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "smol-toml": "^1.6.1",
+    "yaml": "^2.8.4"
+  },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",