squad-openclaw 2026.2.2018 → 2026.2.2020

package/dist/index.js

@@ -104,8 +104,8 @@ function registerAgentMethods(api) {
 
 // src/entities.ts
 import { Type as T } from "@sinclair/typebox";
-import path4 from "path";
-import fs3 from "fs";
+import path5 from "path";
+import fs5 from "fs";
 
 // src/watcher.ts
 import path from "path";
@@ -360,30 +360,129 @@ function startWatcher(configDir, onFsChange) {
 }
 
 // src/filesystem.ts
-import fs2 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // src/paths.ts
 import path2 from "path";
 import os from "os";
+import fs2 from "fs";
 function getOpenclawStateDir() {
-  return process.env.OPENCLAW_STATE_DIR || process.env.OPENCLAW_DIR || path2.join(os.homedir(), ".openclaw");
+  if (process.env.OPENCLAW_STATE_DIR) {
+    return process.env.OPENCLAW_STATE_DIR;
+  }
+  if (process.env.OPENCLAW_CONFIG_PATH) {
+    return path2.dirname(process.env.OPENCLAW_CONFIG_PATH);
+  }
+  const legacyDir = process.env.OPENCLAW_DIR;
+  if (legacyDir) {
+    const resolvedLegacyDir = path2.resolve(legacyDir);
+    const configPath = path2.join(resolvedLegacyDir, "openclaw.json");
+    const hasStateMarkers = fs2.existsSync(configPath) || fs2.existsSync(path2.join(resolvedLegacyDir, "agents")) || fs2.existsSync(path2.join(resolvedLegacyDir, "workspace"));
+    const looksLikeStateDir = resolvedLegacyDir.endsWith(`${path2.sep}.openclaw`);
+    if (hasStateMarkers || looksLikeStateDir) {
+      return resolvedLegacyDir;
+    }
+  }
+  return path2.join(os.homedir(), ".openclaw");
+}
+
+// src/layout.ts
+import fs3 from "fs";
+import path3 from "path";
+function resolveMaybeRelativePath(stateDir, p) {
+  if (path3.isAbsolute(p)) return path3.resolve(p);
+  return path3.resolve(stateDir, p);
+}
+function listWorkspaceFallbacks(stateDir) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(stateDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory() && (entry.name === "workspace" || entry.name.startsWith("workspace-"))).map((entry) => {
+    const agentId = entry.name === "workspace" ? "main" : entry.name.replace("workspace-", "");
+    const workspacePath = path3.join(stateDir, entry.name);
+    return {
+      agentId,
+      path: workspacePath,
+      source: "filesystem",
+      exists: true
+    };
+  });
+}
+function readOpenclawConfig(configPath) {
+  try {
+    const raw = fs3.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveGatewayLayout() {
+  const stateDir = getOpenclawStateDir();
+  const configPath = path3.join(stateDir, "openclaw.json");
+  const config = readOpenclawConfig(configPath);
+  const workspaces = [];
+  if (config?.agents?.main?.workspace || config?.agents?.main?.workspacePath) {
+    const rawPath = config.agents.main.workspace ?? config.agents.main.workspacePath;
+    if (rawPath) {
+      const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
+      workspaces.push({
+        agentId: "main",
+        path: resolvedPath,
+        source: "config",
+        exists: fs3.existsSync(resolvedPath)
+      });
+    }
+  }
+  for (const agent of config?.agents?.list ?? []) {
+    const agentId = typeof agent.id === "string" && agent.id.trim() ? agent.id : null;
+    const rawPath = agent.workspace ?? agent.workspacePath;
+    if (!agentId || !rawPath) continue;
+    const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
+    workspaces.push({
+      agentId,
+      path: resolvedPath,
+      source: "config",
+      exists: fs3.existsSync(resolvedPath)
+    });
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const ws of [...workspaces, ...listWorkspaceFallbacks(stateDir)]) {
+    if (!deduped.has(ws.agentId)) {
+      deduped.set(ws.agentId, ws);
+    }
+  }
+  const resolvedWorkspaces = Array.from(deduped.values());
+  const mainWorkspace = resolvedWorkspaces.find((ws) => ws.agentId === "main");
+  const defaultFileBrowserRoot = mainWorkspace?.path ?? stateDir;
+  return {
+    stateDir,
+    configPath,
+    mediaDir: path3.join(stateDir, "media"),
+    skillsDir: path3.join(stateDir, "skills"),
+    extensionsDir: path3.join(stateDir, "extensions"),
+    defaultFileBrowserRoot,
+    workspaces: resolvedWorkspaces
+  };
 }
 
 // src/filesystem.ts
 var HOME_DIR = process.env.HOME ?? "/root";
 var OPENCLAW_DIR = getOpenclawStateDir();
 var SENSITIVE_BLOCKED_DIRS = [
-  path3.join(OPENCLAW_DIR, "credentials"),
-  path3.join(OPENCLAW_DIR, "devices"),
-  path3.join(OPENCLAW_DIR, "identity")
+  path4.join(OPENCLAW_DIR, "credentials"),
+  path4.join(OPENCLAW_DIR, "devices"),
+  path4.join(OPENCLAW_DIR, "identity")
 ];
 var SENSITIVE_BLOCKED_FILES = [
-  path3.join(OPENCLAW_DIR, "squad-ceo-data", "relay", "squad-relay.json")
+  path4.join(OPENCLAW_DIR, "squad-ceo-data", "relay", "squad-relay.json")
 ];
 function isSensitivePath(resolvedPath) {
   for (const blocked of SENSITIVE_BLOCKED_DIRS) {
-    if (resolvedPath === blocked || resolvedPath.startsWith(blocked + path3.sep)) {
+    if (resolvedPath === blocked || resolvedPath.startsWith(blocked + path4.sep)) {
       return true;
     }
   }
@@ -392,7 +491,7 @@ function isSensitivePath(resolvedPath) {
       return true;
     }
   }
-  if (path3.dirname(resolvedPath) === OPENCLAW_DIR && resolvedPath.endsWith(".bak")) {
+  if (path4.dirname(resolvedPath) === OPENCLAW_DIR && resolvedPath.endsWith(".bak")) {
     return true;
   }
   return false;
@@ -441,20 +540,20 @@ function redactOpenclawJson(rawContent) {
   return JSON.stringify(config, null, 2);
 }
 function isOpenclawJson(resolvedPath) {
-  return path3.basename(resolvedPath) === OPENCLAW_JSON_FILENAME && resolvedPath.startsWith(OPENCLAW_DIR);
+  return path4.basename(resolvedPath) === OPENCLAW_JSON_FILENAME && resolvedPath.startsWith(OPENCLAW_DIR);
 }
 function expandHome(p) {
   if (p.startsWith("~/") || p === "~") {
-    return path3.join(HOME_DIR, p.slice(1));
+    return path4.join(HOME_DIR, p.slice(1));
   }
   return p;
 }
 function validatePath(p, allowedRoots) {
-  const resolved = path3.resolve(expandHome(p));
+  const resolved = path4.resolve(expandHome(p));
   if (!allowedRoots || allowedRoots.length === 0) return resolved;
   const allowed = allowedRoots.some((root) => {
-    const resolvedRoot = path3.resolve(expandHome(root));
-    return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path3.sep);
+    const resolvedRoot = path4.resolve(expandHome(root));
+    return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path4.sep);
   });
   if (!allowed) {
     throw new Error(`Path "${p}" is outside allowed roots`);
@@ -491,18 +590,18 @@ function err(message) {
   };
 }
 function listDir(dirPath, opts) {
-  const dirents = fs2.readdirSync(dirPath, { withFileTypes: true });
+  const dirents = fs4.readdirSync(dirPath, { withFileTypes: true });
   const results = [];
   for (const dirent of dirents) {
     if (!opts.includeHidden && dirent.name.startsWith(".")) continue;
-    const entryPath = path3.join(dirPath, dirent.name);
+    const entryPath = path4.join(dirPath, dirent.name);
     let type = "other";
     if (dirent.isFile()) type = "file";
     else if (dirent.isDirectory()) type = "directory";
     else if (dirent.isSymbolicLink()) type = "symlink";
     const entry = { name: dirent.name, path: entryPath, type };
     try {
-      const stat = fs2.statSync(entryPath);
+      const stat = fs4.statSync(entryPath);
       entry.size = stat.size;
       entry.modified = stat.mtime.toISOString();
     } catch {
@@ -526,7 +625,11 @@ function filterSensitiveEntries(entries) {
   });
 }
 function registerFilesystemTools(api) {
-  const DEFAULT_ALLOWED_ROOTS = [OPENCLAW_DIR];
+  const layout = resolveGatewayLayout();
+  const DEFAULT_ALLOWED_ROOTS = Array.from(/* @__PURE__ */ new Set([
+    OPENCLAW_DIR,
+    ...layout.workspaces.map((ws) => ws.path)
+  ]));
   const allowedRoots = api.pluginConfig?.["fs.allowedRoots"] ?? DEFAULT_ALLOWED_ROOTS;
   api.registerTool({
     name: "fs_read",
@@ -551,8 +654,8 @@ function registerFilesystemTools(api) {
       try {
         const filePath = validateAndBlockSensitive(params.path, allowedRoots);
         const encoding = params.encoding ?? "utf-8";
-        let content = fs2.readFileSync(filePath, encoding);
-        const stat = fs2.statSync(filePath);
+        let content = fs4.readFileSync(filePath, encoding);
+        const stat = fs4.statSync(filePath);
         if (isOpenclawJson(filePath) && encoding === "utf-8") {
           content = redactOpenclawJson(content);
         }
@@ -602,10 +705,10 @@ function registerFilesystemTools(api) {
         const encoding = params.encoding ?? "utf-8";
         const mkdir = params.mkdir !== false;
         if (mkdir) {
-          fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+          fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
         }
-        fs2.writeFileSync(filePath, content, encoding);
-        const stat = fs2.statSync(filePath);
+        fs4.writeFileSync(filePath, content, encoding);
+        const stat = fs4.statSync(filePath);
         return ok({
           path: filePath,
           size: stat.size,
@@ -674,7 +777,7 @@ function registerFilesystemTools(api) {
     async execute(_id, params) {
       try {
         const targetPath = validateWritePath(params.path, allowedRoots);
-        fs2.mkdirSync(targetPath, { recursive: true });
+        fs4.mkdirSync(targetPath, { recursive: true });
         return ok({
           path: targetPath,
           created: true
@@ -707,7 +810,7 @@ function registerFilesystemTools(api) {
       try {
         const resolvedOld = validateWritePath(params.oldPath, allowedRoots);
         const resolvedNew = validateWritePath(params.newPath, allowedRoots);
-        fs2.renameSync(resolvedOld, resolvedNew);
+        fs4.renameSync(resolvedOld, resolvedNew);
         return ok({
           oldPath: resolvedOld,
           newPath: resolvedNew,
@@ -736,12 +839,12 @@ function registerFilesystemTools(api) {
     async execute(_id, params) {
       try {
         const targetPath = validateWritePath(params.path, allowedRoots);
-        const stat = fs2.statSync(targetPath);
+        const stat = fs4.statSync(targetPath);
         const wasDirectory = stat.isDirectory();
         if (wasDirectory) {
-          fs2.rmSync(targetPath, { recursive: true });
+          fs4.rmSync(targetPath, { recursive: true });
         } else {
-          fs2.unlinkSync(targetPath);
+          fs4.unlinkSync(targetPath);
         }
         return ok({
           path: targetPath,
@@ -793,7 +896,7 @@ function scanAgents(configDir) {
   const now = Date.now();
   let entries;
   try {
-    entries = fs3.readdirSync(configDir, { withFileTypes: true });
+    entries = fs5.readdirSync(configDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -802,20 +905,20 @@ function scanAgents(configDir) {
   );
   for (const dir of workspaceDirs) {
     const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
-    const workspacePath = path4.join(configDir, dir.name);
+    const workspacePath = path5.join(configDir, dir.name);
     let name = agentId;
     const metadata = { workspacePath };
-    const identityPath = path4.join(workspacePath, "IDENTITY.md");
+    const identityPath = path5.join(workspacePath, "IDENTITY.md");
     try {
-      const content = fs3.readFileSync(identityPath, "utf-8");
+      const content = fs5.readFileSync(identityPath, "utf-8");
       const parsed = parseIdentityName(content);
       if (parsed) name = parsed;
     } catch {
     }
     if (name === agentId) {
-      const agentJsonPath = path4.join(workspacePath, "agent.json");
+      const agentJsonPath = path5.join(workspacePath, "agent.json");
       try {
-        const raw = fs3.readFileSync(agentJsonPath, "utf-8");
+        const raw = fs5.readFileSync(agentJsonPath, "utf-8");
         const config = JSON.parse(raw);
         if (config.displayName) name = config.displayName;
         if (config.model) metadata.model = config.model;
@@ -840,11 +943,11 @@ function scanAgents(configDir) {
 }
 function scanSkills(configDir) {
   const now = Date.now();
-  const globalSkillsDir = path4.join(configDir, "skills");
+  const globalSkillsDir = path5.join(configDir, "skills");
   scanSkillsDir(globalSkillsDir, "global", now);
   let entries;
   try {
-    entries = fs3.readdirSync(configDir, { withFileTypes: true });
+    entries = fs5.readdirSync(configDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -853,26 +956,26 @@ function scanSkills(configDir) {
       continue;
     }
     const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
-    const agentSkillsDir = path4.join(configDir, dir.name, "skills");
+    const agentSkillsDir = path5.join(configDir, dir.name, "skills");
     scanSkillsDir(agentSkillsDir, agentId, now);
   }
 }
 function scanSkillsDir(skillsDir, scope, now) {
   let entries;
   try {
-    entries = fs3.readdirSync(skillsDir, { withFileTypes: true });
+    entries = fs5.readdirSync(skillsDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const skillKey = entry.name;
-    const skillPath = path4.join(skillsDir, skillKey);
+    const skillPath = path5.join(skillsDir, skillKey);
     let name = skillKey;
     for (const manifestName of ["manifest.json", "package.json"]) {
       try {
-        const raw = fs3.readFileSync(
-          path4.join(skillPath, manifestName),
+        const raw = fs5.readFileSync(
+          path5.join(skillPath, manifestName),
           "utf-8"
         );
         const manifest = JSON.parse(raw);
@@ -899,19 +1002,19 @@ function scanSkillsDir(skillsDir, scope, now) {
 }
 function scanPlugins2(configDir) {
   const now = Date.now();
-  const extensionsDir = path4.join(configDir, "extensions");
+  const extensionsDir = path5.join(configDir, "extensions");
   let entries;
   try {
-    entries = fs3.readdirSync(extensionsDir, { withFileTypes: true });
+    entries = fs5.readdirSync(extensionsDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const dir of entries) {
     if (!dir.isDirectory()) continue;
-    const pluginDir = path4.join(extensionsDir, dir.name);
-    const manifestPath = path4.join(pluginDir, "openclaw.plugin.json");
+    const pluginDir = path5.join(extensionsDir, dir.name);
+    const manifestPath = path5.join(pluginDir, "openclaw.plugin.json");
     try {
-      const raw = fs3.readFileSync(manifestPath, "utf-8");
+      const raw = fs5.readFileSync(manifestPath, "utf-8");
       const manifest = JSON.parse(raw);
       const pluginId = manifest.id || dir.name;
       const name = manifest.name || pluginId;
@@ -934,8 +1037,8 @@ function scanPlugins2(configDir) {
 function scanTools(configDir) {
   const now = Date.now();
   try {
-    const raw = fs3.readFileSync(
-      path4.join(configDir, "openclaw.json"),
+    const raw = fs5.readFileSync(
+      path5.join(configDir, "openclaw.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -986,24 +1089,24 @@ var MIME_MAP = {
   ".gz": "application/gzip"
 };
 function getMimeType(filename) {
-  const ext = path4.extname(filename).toLowerCase();
+  const ext = path5.extname(filename).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function scanMedia(configDir) {
   const now = Date.now();
-  const mediaDir = path4.join(configDir, "media");
+  const mediaDir = path5.join(configDir, "media");
   scanMediaDir(mediaDir, now);
 }
 function scanMediaDir(dirPath, now) {
   let entries;
   try {
-    entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+    entries = fs5.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path4.join(dirPath, entry.name);
+    const entryPath = path5.join(dirPath, entry.name);
     if (isSensitivePath(entryPath)) continue;
     if (entry.isDirectory()) {
       registrySet({
@@ -1024,7 +1127,7 @@ function scanMediaDir(dirPath, now) {
       let size;
       let mtime = now;
       try {
-        const stat = fs3.statSync(entryPath);
+        const stat = fs5.statSync(entryPath);
         size = stat.size;
         mtime = stat.mtimeMs;
       } catch {
@@ -1141,24 +1244,24 @@ function registerEntityTools(api, onFsChange) {
 
 // src/sql.ts
 import { execFile } from "child_process";
-import path5 from "path";
-import fs4 from "fs";
+import path6 from "path";
+import fs6 from "fs";
 import { Type as T2 } from "@sinclair/typebox";
 var HOME_DIR2 = process.env.HOME ?? "/root";
-var ALLOWED_DATA_DIR = path5.join(getOpenclawStateDir(), "squad-ceo-data");
+var ALLOWED_DATA_DIR = path6.join(getOpenclawStateDir(), "squad-ceo-data");
 function validateDbPath(dbPath) {
   let expanded = dbPath;
   if (expanded.startsWith("~/") || expanded === "~") {
-    expanded = path5.join(HOME_DIR2, expanded.slice(1));
+    expanded = path6.join(HOME_DIR2, expanded.slice(1));
   }
-  const resolved = path5.resolve(expanded);
-  if (resolved !== ALLOWED_DATA_DIR && !resolved.startsWith(ALLOWED_DATA_DIR + path5.sep)) {
+  const resolved = path6.resolve(expanded);
+  if (resolved !== ALLOWED_DATA_DIR && !resolved.startsWith(ALLOWED_DATA_DIR + path6.sep)) {
     throw new Error(
       `Access denied: database path must be within ~/.openclaw/squad-ceo-data/`
     );
   }
   try {
-    const stat = fs4.statSync(resolved);
+    const stat = fs6.statSync(resolved);
     if (!stat.isFile()) {
       throw new Error(`Not a file: ${dbPath}`);
     }
@@ -1225,18 +1328,18 @@ function registerSqlTools(api) {
 
 // src/version.ts
 import { execSync as execSync2 } from "child_process";
-import fs5 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "squad-openclaw";
-var CONFIG_PATH = path6.join(getOpenclawStateDir(), "openclaw.json");
+var CONFIG_PATH = path7.join(getOpenclawStateDir(), "openclaw.json");
 var updateInProgress = false;
 var VERIFY_TIMEOUT_MS = 2e4;
 var VERIFY_INTERVAL_MS = 500;
 var RESTART_BUFFER_MS = 5e3;
 function readInstalledVersionFromConfig() {
   try {
-    const raw = fs5.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs7.readFileSync(CONFIG_PATH, "utf-8");
     const cfg = JSON.parse(raw);
     const v = cfg?.plugins?.installs?.[PACKAGE_NAME]?.version;
     return typeof v === "string" ? v : null;
@@ -1247,7 +1350,7 @@ function readInstalledVersionFromConfig() {
 function reconcileInstallMetadata(verification) {
   if (!verification.installPath || !verification.packageVersion) return;
   try {
-    const raw = fs5.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs7.readFileSync(CONFIG_PATH, "utf-8");
     const config = JSON.parse(raw);
     if (!config.plugins || typeof config.plugins !== "object") config.plugins = {};
     if (!config.plugins.installs || typeof config.plugins.installs !== "object") {
@@ -1270,15 +1373,15 @@ function reconcileInstallMetadata(verification) {
       ...entry,
       enabled: true
     };
-    fs5.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+    fs7.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
   } catch {
   }
 }
 function getCurrentVersion() {
   const thisFile = fileURLToPath(import.meta.url);
-  const pkgPath = path6.resolve(path6.dirname(thisFile), "..", "package.json");
+  const pkgPath = path7.resolve(path7.dirname(thisFile), "..", "package.json");
   try {
-    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -1323,7 +1426,7 @@ function compareVersions(a, b) {
 function verifyInstalledPluginState() {
   let configRaw;
   try {
-    configRaw = fs5.readFileSync(CONFIG_PATH, "utf-8");
+    configRaw = fs7.readFileSync(CONFIG_PATH, "utf-8");
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
     return {
@@ -1363,11 +1466,11 @@ function verifyInstalledPluginState() {
     };
   }
   const requiredFiles = [
-    path6.join(installPath, "package.json"),
-    path6.join(installPath, "openclaw.plugin.json"),
-    path6.join(installPath, "dist", "index.js")
+    path7.join(installPath, "package.json"),
+    path7.join(installPath, "openclaw.plugin.json"),
+    path7.join(installPath, "dist", "index.js")
   ];
-  const requiredFilesMissing = requiredFiles.filter((p) => !fs5.existsSync(p));
+  const requiredFilesMissing = requiredFiles.filter((p) => !fs7.existsSync(p));
   if (requiredFilesMissing.length > 0) {
     return {
       ok: false,
@@ -1381,7 +1484,7 @@ function verifyInstalledPluginState() {
   let installedPackage;
   try {
     installedPackage = JSON.parse(
-      fs5.readFileSync(path6.join(installPath, "package.json"), "utf-8")
+      fs7.readFileSync(path7.join(installPath, "package.json"), "utf-8")
     );
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -1396,7 +1499,7 @@ function verifyInstalledPluginState() {
   }
   try {
     JSON.parse(
-      fs5.readFileSync(path6.join(installPath, "openclaw.plugin.json"), "utf-8")
+      fs7.readFileSync(path7.join(installPath, "openclaw.plugin.json"), "utf-8")
     );
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -1486,7 +1589,7 @@ function registerVersionMethods(api) {
         let updateOutput = "";
         let configBackup = null;
         try {
-          configBackup = fs5.readFileSync(CONFIG_PATH, "utf-8");
+          configBackup = fs7.readFileSync(CONFIG_PATH, "utf-8");
         } catch {
         }
         runDoctorFixSilently();
@@ -1505,7 +1608,7 @@ function registerVersionMethods(api) {
           } catch (installErr) {
             if (configBackup) {
               try {
-                fs5.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
+                fs7.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
               } catch {
               }
             }
@@ -1523,7 +1626,7 @@ function registerVersionMethods(api) {
         if (!verification.ok) {
           if (configBackup) {
             try {
-              fs5.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
+              fs7.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
             } catch {
             }
           }
@@ -1581,8 +1684,8 @@ function registerVersionMethods(api) {
 // src/relay-client.ts
 import { WebSocket as NodeWebSocket } from "ws";
 import crypto3 from "crypto";
-import fs7 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
 // src/e2e-crypto.ts
 import crypto from "crypto";
@@ -1663,24 +1766,24 @@ var E2ECrypto = class {
 
 // src/device-keys.ts
 import crypto2 from "crypto";
-import fs6 from "fs";
-import path7 from "path";
-var RELAY_DATA_DIR = path7.join(getOpenclawStateDir(), "squad-ceo-data", "relay");
-var RELAY_STATE_PATH = path7.join(RELAY_DATA_DIR, "squad-relay.json");
-var PENDING_APPROVAL_PATH = path7.join(RELAY_DATA_DIR, "pending-approval.json");
+import fs8 from "fs";
+import path8 from "path";
+var RELAY_DATA_DIR = path8.join(getOpenclawStateDir(), "squad-ceo-data", "relay");
+var RELAY_STATE_PATH = path8.join(RELAY_DATA_DIR, "squad-relay.json");
+var PENDING_APPROVAL_PATH = path8.join(RELAY_DATA_DIR, "pending-approval.json");
 function readRelayState() {
   try {
-    const raw = fs6.readFileSync(RELAY_STATE_PATH, "utf-8");
+    const raw = fs8.readFileSync(RELAY_STATE_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 function writeRelayState(state) {
-  if (!fs6.existsSync(RELAY_DATA_DIR)) {
-    fs6.mkdirSync(RELAY_DATA_DIR, { recursive: true });
+  if (!fs8.existsSync(RELAY_DATA_DIR)) {
+    fs8.mkdirSync(RELAY_DATA_DIR, { recursive: true });
   }
-  fs6.writeFileSync(RELAY_STATE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
+  fs8.writeFileSync(RELAY_STATE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
 }
 function toBase64Url(buf) {
   return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
@@ -1703,7 +1806,7 @@ function loadOrCreateRelayDeviceKeys() {
 }
 function writeDeviceInfoFile(keys) {
   const stateDir = getOpenclawStateDir();
-  const infoPath = path7.join(stateDir, "squad-ceo-data", "relay", "relay-device-info.json");
+  const infoPath = path8.join(stateDir, "squad-ceo-data", "relay", "relay-device-info.json");
   const info = {
     deviceId: keys.deviceId,
     publicKey: keys.publicKey,
@@ -1712,7 +1815,7 @@ function writeDeviceInfoFile(keys) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs6.writeFileSync(infoPath, JSON.stringify(info, null, 2));
+    fs8.writeFileSync(infoPath, JSON.stringify(info, null, 2));
   } catch (err2) {
     console.error("[device-keys] Failed to write relay-device-info.json:", err2);
   }
@@ -1721,9 +1824,9 @@ function writeDeviceInfoFile(keys) {
 // src/relay-client.ts
 function readOperatorToken() {
   const stateDir = getOpenclawStateDir();
-  const configPath = path8.join(stateDir, "openclaw.json");
+  const configPath = path9.join(stateDir, "openclaw.json");
   try {
-    const raw = fs7.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config?.gateway?.auth?.token ?? config?.gateway?.remote?.token ?? config?.gateway?.token ?? null;
   } catch {
@@ -1737,9 +1840,9 @@ function readGatewayLocalWsConfig() {
     hosts: ["127.0.0.1", "localhost", "[::1]"]
   };
   const stateDir = getOpenclawStateDir();
-  const configPath = path8.join(stateDir, "openclaw.json");
+  const configPath = path9.join(stateDir, "openclaw.json");
   try {
-    const raw = fs7.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     const parsedPort = Number(config?.gateway?.port);
     if (Number.isFinite(parsedPort) && parsedPort > 0) {
@@ -2285,88 +2388,6 @@ function broadcastToUsers(event, payload) {
   relayClient?.broadcastToUsers(event, payload);
 }
 
-// src/layout.ts
-import fs8 from "fs";
-import path9 from "path";
-function resolveMaybeRelativePath(stateDir, p) {
-  if (path9.isAbsolute(p)) return path9.resolve(p);
-  return path9.resolve(stateDir, p);
-}
-function listWorkspaceFallbacks(stateDir) {
-  let entries;
-  try {
-    entries = fs8.readdirSync(stateDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((entry) => entry.isDirectory() && (entry.name === "workspace" || entry.name.startsWith("workspace-"))).map((entry) => {
-    const agentId = entry.name === "workspace" ? "main" : entry.name.replace("workspace-", "");
-    const workspacePath = path9.join(stateDir, entry.name);
-    return {
-      agentId,
-      path: workspacePath,
-      source: "filesystem",
-      exists: true
-    };
-  });
-}
-function readOpenclawConfig(configPath) {
-  try {
-    const raw = fs8.readFileSync(configPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function resolveGatewayLayout() {
-  const stateDir = getOpenclawStateDir();
-  const configPath = path9.join(stateDir, "openclaw.json");
-  const config = readOpenclawConfig(configPath);
-  const workspaces = [];
-  if (config?.agents?.main?.workspace || config?.agents?.main?.workspacePath) {
-    const rawPath = config.agents.main.workspace ?? config.agents.main.workspacePath;
-    if (rawPath) {
-      const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
-      workspaces.push({
-        agentId: "main",
-        path: resolvedPath,
-        source: "config",
-        exists: fs8.existsSync(resolvedPath)
-      });
-    }
-  }
-  for (const agent of config?.agents?.list ?? []) {
-    const agentId = typeof agent.id === "string" && agent.id.trim() ? agent.id : null;
-    const rawPath = agent.workspace ?? agent.workspacePath;
-    if (!agentId || !rawPath) continue;
-    const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
-    workspaces.push({
-      agentId,
-      path: resolvedPath,
-      source: "config",
-      exists: fs8.existsSync(resolvedPath)
-    });
-  }
-  const deduped = /* @__PURE__ */ new Map();
-  for (const ws of [...workspaces, ...listWorkspaceFallbacks(stateDir)]) {
-    if (!deduped.has(ws.agentId)) {
-      deduped.set(ws.agentId, ws);
-    }
-  }
-  const resolvedWorkspaces = Array.from(deduped.values());
-  const mainWorkspace = resolvedWorkspaces.find((ws) => ws.agentId === "main");
-  const defaultFileBrowserRoot = mainWorkspace?.path ?? stateDir;
-  return {
-    stateDir,
-    configPath,
-    mediaDir: path9.join(stateDir, "media"),
-    skillsDir: path9.join(stateDir, "skills"),
-    extensionsDir: path9.join(stateDir, "extensions"),
-    defaultFileBrowserRoot,
-    workspaces: resolvedWorkspaces
-  };
-}
-
 // src/index.ts
 function squadAppPlugin(api) {
   const toolExecutors = /* @__PURE__ */ new Map();
@@ -2453,7 +2474,9 @@ function squadAppPlugin(api) {
     "squad.layout.get",
     async ({ respond }) => {
       try {
-        respond(true, resolveGatewayLayout());
+        const layout = resolveGatewayLayout();
+        console.log("[squad-openclaw] squad.layout.get", JSON.stringify(layout));
+        respond(true, layout);
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
         respond(false, { errorMessage: msg });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squad-openclaw",
-  "version": "2026.2.2018",
+  "version": "2026.2.2020",
   "description": "Entity registry, filesystem tools, and version management plugin for OpenClaw gateway",
   "type": "module",
   "main": "./dist/index.js",