@venturewild/workspace 0.1.0

package/server/src/config.mjs

@@ -0,0 +1,236 @@
+// Central config + role definitions.
+// One UI permission-flagged per AR-19.
+
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Secrets that shipped as scaffold defaults. Forgeable — never allowed on a
+// non-localhost bind. Kept only so the startup guard can recognise them.
+export const WEAK_SECRETS = Object.freeze(
+  new Set(['dev-partner-token', 'dev-share-secret-change-me']),
+);
+
+const LOCAL_HOSTS = Object.freeze(new Set(['127.0.0.1', 'localhost', '::1']));
+
+export function isLocalhost(host) {
+  return LOCAL_HOSTS.has(host);
+}
+
+// The bmo-sync daemon's HTTP origin, derived from its WebSocket event-feed
+// URL so the two stay consistent when WILD_WORKSPACE_DAEMON_URL is overridden.
+function daemonHttpBase(wsUrl) {
+  try {
+    const u = new URL(wsUrl);
+    return `${u.protocol === 'wss:' ? 'https:' : 'http:'}//${u.host}`;
+  } catch {
+    return 'http://127.0.0.1:8320';
+  }
+}
+
+// Per-install secrets. Generated once, persisted to <dataDir>/secrets.json
+// (the .wild-workspace dir is gitignored). Replaces the weak scaffold defaults
+// so share tokens can't be forged. (Concern C2.)
+function loadOrCreateSecrets(dataDir) {
+  const secretsPath = path.join(dataDir, 'secrets.json');
+  try {
+    const parsed = JSON.parse(fs.readFileSync(secretsPath, 'utf8'));
+    if (parsed.partnerToken && parsed.shareSecret) return parsed;
+  } catch {
+    // missing / unreadable / malformed — fall through and regenerate
+  }
+  const generated = {
+    partnerToken: crypto.randomBytes(24).toString('base64url'),
+    shareSecret: crypto.randomBytes(32).toString('base64url'),
+  };
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(secretsPath, JSON.stringify(generated, null, 2), { mode: 0o600 });
+  } catch {
+    // can't persist (read-only fs?) — still use the generated pair for this run
+  }
+  return generated;
+}
+
+// Refuse to start in public mode with a forgeable secret. (Concerns C1/C2.)
+export function assertSecureBinding(config) {
+  if (!config.publicMode) return;
+  if (WEAK_SECRETS.has(config.partnerToken) || WEAK_SECRETS.has(config.shareSecret)) {
+    throw new Error(
+      `Refusing to run in public mode with a default secret. ` +
+        `Set WILD_WORKSPACE_PARTNER_TOKEN and WILD_WORKSPACE_SHARE_SECRET, ` +
+        `or remove them so per-install secrets are generated.`,
+    );
+  }
+}
+
+export const ROLES = Object.freeze({
+  PARTNER: 'partner',
+  VIEWER: 'viewer',
+  CLIENT: 'client',
+});
+
+export const ROLE_CAPABILITIES = Object.freeze({
+  partner: {
+    chat: true,
+    chatWrite: true,
+    preview: true,
+    fileTree: true,
+    terminal: true,
+    inbox: true,
+    share: true,
+    sync: true,
+    deploy: true,
+    requestChanges: false,
+  },
+  viewer: {
+    chat: true,
+    chatWrite: false,
+    preview: true,
+    fileTree: false,
+    terminal: false,
+    inbox: false,
+    share: false,
+    sync: false,
+    deploy: false,
+    requestChanges: false,
+  },
+  client: {
+    chat: true,
+    chatWrite: true,
+    preview: true,
+    fileTree: false,
+    terminal: false,
+    inbox: false,
+    share: false,
+    sync: false,
+    deploy: false,
+    requestChanges: true,
+  },
+});
+
+export const DEFAULT_AGENTS = Object.freeze([
+  {
+    id: 'claude',
+    binary: 'claude',
+    label: 'Claude Code',
+    description: 'Anthropic Claude Code',
+    args: ['-p', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'],
+    streamFormat: 'claude-stream-json',
+  },
+  {
+    id: 'gemini',
+    binary: 'gemini',
+    label: 'Gemini CLI',
+    description: 'Google Gemini',
+    args: ['-p'],
+    streamFormat: 'text',
+  },
+  {
+    id: 'glm',
+    binary: 'glm',
+    label: 'GLM (Z.AI)',
+    description: 'GLM-4.6 via Z.AI',
+    args: ['-p', '--permission-mode', 'bypassPermissions'],
+    streamFormat: 'text',
+  },
+  {
+    id: 'codex',
+    binary: 'codex',
+    label: 'Codex (OpenAI)',
+    description: 'GPT-5 / o3 via Codex CLI',
+    args: ['exec', '--skip-git-repo-check'],
+    streamFormat: 'text',
+  },
+]);
+
+export function buildConfig(overrides = {}) {
+  const env = process.env;
+  const portOverride = overrides.port;
+  const resolvedPort =
+    typeof portOverride === 'number'
+      ? portOverride
+      : Number(env.WILD_WORKSPACE_PORT || 5173);
+  const workspaceDir = path.resolve(
+    overrides.workspaceDir || env.WILD_WORKSPACE_DIR || process.cwd(),
+  );
+  const dataDir = path.resolve(
+    overrides.dataDir ||
+      env.WILD_WORKSPACE_DATA_DIR ||
+      path.join(workspaceDir, '.wild-workspace'),
+  );
+  // Lazy: only load/generate persisted secrets if neither an override nor an
+  // env var supplies one — keeps tests that pass both from touching the fs.
+  let _secrets = null;
+  const secrets = () => (_secrets ??= loadOrCreateSecrets(dataDir));
+  const host = overrides.host || env.WILD_WORKSPACE_HOST || '127.0.0.1';
+  // publicMode = "treat every request as untrusted". True for a non-localhost
+  // bind, OR when WILD_WORKSPACE_PUBLIC=1 — needed when a tunnel (Cloudflare
+  // etc.) forwards public traffic to a localhost-bound server, since the bind
+  // address alone would otherwise look local. Drives the C1 auth posture.
+  const publicMode =
+    overrides.publicMode ??
+    (env.WILD_WORKSPACE_PUBLIC === '1' || !isLocalhost(host));
+  // bmo-sync: the local daemon's event feed (a WebSocket URL).
+  const daemonUrl =
+    overrides.daemonUrl ||
+    env.WILD_WORKSPACE_DAEMON_URL ||
+    'ws://127.0.0.1:8320/api/events';
+  return {
+    port: resolvedPort,
+    host,
+    publicMode,
+    workspaceDir,
+    dataDir,
+    webDir:
+      overrides.webDir ||
+      env.WILD_WORKSPACE_WEB_DIR ||
+      path.resolve(__dirname, '..', '..', 'web', 'dist'),
+    openBrowser: overrides.openBrowser ?? env.WILD_WORKSPACE_NO_OPEN !== '1',
+    shareBaseUrl:
+      overrides.shareBaseUrl ||
+      env.WILD_WORKSPACE_SHARE_BASE_URL ||
+      `http://${host}:${resolvedPort}`,
+    partnerToken:
+      overrides.partnerToken ||
+      env.WILD_WORKSPACE_PARTNER_TOKEN ||
+      secrets().partnerToken,
+    shareSecret:
+      overrides.shareSecret ||
+      env.WILD_WORKSPACE_SHARE_SECRET ||
+      secrets().shareSecret,
+    workspaceId:
+      overrides.workspaceId ||
+      env.WILD_WORKSPACE_ID ||
+      path.basename(workspaceDir) ||
+      'workspace',
+    role: overrides.role || env.WILD_WORKSPACE_ROLE || ROLES.PARTNER,
+    // bmo-sync daemon — a separate local process; the bridge retries quietly
+    // when it is absent. daemonUrl is the WebSocket event feed; daemonHttpUrl
+    // is the same origin's HTTP API (pair / detach / list).
+    daemonUrl,
+    daemonHttpUrl: daemonHttpBase(daemonUrl),
+    // Central bmo-sync server (Fly.io). Used to redeem invites (via the
+    // daemon) and — only when an admin key is set — to mint them.
+    bmoSyncServerUrl:
+      overrides.bmoSyncServerUrl ||
+      env.WILD_WORKSPACE_BMO_SYNC_URL ||
+      env.BMO_SYNC_URL ||
+      'https://sync.venturewild.llc',
+    // Optional. Present only on an install that mints invites (the folder
+    // owner). Absent installs can still redeem. Never sent to the browser.
+    bmoSyncAdminKey:
+      overrides.bmoSyncAdminKey ||
+      env.BMO_SYNC_ADMIN_KEY ||
+      env.WILD_WORKSPACE_BMO_ADMIN_KEY ||
+      null,
+    home: os.homedir(),
+    nodeEnv: env.NODE_ENV || 'production',
+  };
+}
+
+export const APP_VERSION = '0.1.0';

package/server/src/daemon-bin.mjs

@@ -0,0 +1,66 @@
+// Locates the bmo-sync-daemon binary for the current platform.
+//
+// wild-workspace ships the daemon as a per-platform npm subpackage
+// (@venturewild/workspace-daemon-<tag>, biome pattern). The resolver walks a
+// lookup chain so it works both in development (a locally built binary in
+// vendor/ or on PATH) and in a published install (the platform subpackage).
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { createRequire } from 'node:module';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+/** `<platform>-<arch>` token, e.g. `win32-x64`, `darwin-arm64`, `linux-x64`. */
+export function platformTag() {
+  return `${process.platform}-${process.arch}`;
+}
+
+/** Daemon binary file name for the current platform. */
+export function daemonBinaryName() {
+  return process.platform === 'win32' ? 'bmo-sync-daemon.exe' : 'bmo-sync-daemon';
+}
+
+/**
+ * Resolve the daemon binary. Lookup order:
+ *   1. WILD_WORKSPACE_DAEMON_BIN — explicit override (must exist, or null).
+ *   2. the per-platform npm subpackage `@venturewild/workspace-daemon-<tag>`.
+ *   3. a local `vendor/bmo-sync-daemon-<tag>/<bin>` dir (dev builds land here).
+ *   4. the bare binary name — let the OS resolve it on PATH at spawn time.
+ *
+ * Returns `{ path, source }`. `source` is one of `env` | `subpackage` |
+ * `vendor` | `path`. Returns `null` only when an explicit override is set
+ * but missing — every other case falls through to the PATH last resort.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv, vendorRoot?: string }} [opts]
+ */
+export function resolveDaemonBinary({ env = process.env, vendorRoot } = {}) {
+  const binName = daemonBinaryName();
+  const tag = platformTag();
+
+  // 1. explicit override — if set but missing, that's an error, not a miss.
+  const override = env.WILD_WORKSPACE_DAEMON_BIN;
+  if (override) {
+    return existsSync(override) ? { path: override, source: 'env' } : null;
+  }
+
+  // 2. per-platform npm subpackage — resolve via its package.json so the
+  //    lookup doesn't depend on an `exports` map for the binary file.
+  try {
+    const pkgJson = require.resolve(`@venturewild/workspace-daemon-${tag}/package.json`);
+    const candidate = path.join(path.dirname(pkgJson), binName);
+    if (existsSync(candidate)) return { path: candidate, source: 'subpackage' };
+  } catch {
+    // subpackage not installed — fall through
+  }
+
+  // 3. local vendor dir (a dev build of the daemon drops the binary here).
+  const root = vendorRoot || path.resolve(__dirname, '..', '..', 'vendor');
+  const vendor = path.join(root, `bmo-sync-daemon-${tag}`, binName);
+  if (existsSync(vendor)) return { path: vendor, source: 'vendor' };
+
+  // 4. last resort — spawn by name and let PATH resolve it.
+  return { path: binName, source: 'path' };
+}

package/server/src/daemon.mjs

@@ -0,0 +1,178 @@
+// Bridge to the bmo-sync daemon's event feed.
+//
+// The daemon (a separate Rust process) broadcasts SyncEvents over a
+// WebSocket. This bridge:
+//   - republishes daemon SyncEvents (conflict / fatal / presence) into the
+//     in-process ActivityBus, so they reach browsers over /ws/activity;
+//   - pushes this machine's local presence (focus changes on /ws/activity)
+//     up to the daemon, which relays it to peers via the central server.
+//
+// The daemon may not be running — the bridge retries with backoff, and every
+// outbound call is best-effort and never throws into the server.
+
+import WebSocket from 'ws';
+
+const INITIAL_RECONNECT_MS = 1000;
+const MAX_RECONNECT_MS = 30000;
+
+export class DaemonBridge {
+  constructor(activityBus, { url } = {}) {
+    this.activityBus = activityBus;
+    this.url = url || 'ws://127.0.0.1:8320/api/events';
+    this.httpBase = httpBaseFrom(this.url);
+    this.ws = null;
+    this.stopped = false;
+    this.connected = false;
+    this.reconnectMs = INITIAL_RECONNECT_MS;
+    this.reconnectTimer = null;
+    // The daemon's id for the workspace — discovered on connect; needed to
+    // address presence reports.
+    this.workspaceId = null;
+    this._onBusEvent = (e) => this._forwardLocalPresence(e);
+  }
+
+  start() {
+    this.stopped = false;
+    this.activityBus.on('event', this._onBusEvent);
+    this._connect();
+    return this;
+  }
+
+  stop() {
+    this.stopped = true;
+    this.activityBus.off('event', this._onBusEvent);
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.terminate();
+      } catch {}
+      this.ws = null;
+    }
+  }
+
+  _connect() {
+    if (this.stopped) return;
+    let ws;
+    try {
+      ws = new WebSocket(this.url);
+    } catch {
+      this._scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.on('open', () => {
+      this.connected = true;
+      this.reconnectMs = INITIAL_RECONNECT_MS;
+      this.activityBus.publish({ type: 'daemon-status', connected: true });
+      void this._discoverWorkspace();
+    });
+    ws.on('message', (raw) => this._onMessage(raw));
+    ws.on('close', () => this._onDown());
+    // 'error' (e.g. connection refused) is always followed by 'close'.
+    ws.on('error', () => {});
+  }
+
+  _onDown() {
+    if (this.connected) {
+      this.connected = false;
+      this.activityBus.publish({ type: 'daemon-status', connected: false });
+    }
+    this.workspaceId = null;
+    this.ws = null;
+    this._scheduleReconnect();
+  }
+
+  _scheduleReconnect() {
+    if (this.stopped || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this._connect();
+    }, this.reconnectMs);
+    this.reconnectMs = Math.min(this.reconnectMs * 2, MAX_RECONNECT_MS);
+  }
+
+  // Learn the daemon's workspace id (needed to address presence reports).
+  // v1: a daemon syncs one workspace for the trial — take the first.
+  async _discoverWorkspace() {
+    try {
+      const res = await fetch(`${this.httpBase}/api/workspaces`);
+      if (!res.ok) return;
+      const data = await res.json();
+      const first = Array.isArray(data.workspaces) ? data.workspaces[0] : null;
+      if (first && first.workspaceId) this.workspaceId = first.workspaceId;
+    } catch {
+      // daemon unreachable — presence push stays disabled until reconnect
+    }
+  }
+
+  // Local presence (a /ws/activity session joined or changed focus) — relay
+  // it to the daemon. `remote-presence` events (our own republished output)
+  // are deliberately not matched here, so there is no echo loop.
+  _forwardLocalPresence(e) {
+    if (!e || (e.type !== 'presence-focus' && e.type !== 'presence-join')) return;
+    const focus = typeof e.focus === 'string' ? e.focus : null;
+    void this.reportPresence({ status: 'viewing', focus });
+  }
+
+  // POST a presence update to the daemon, which relays it to peers.
+  async reportPresence({ status, focus }) {
+    if (!this.connected || !this.workspaceId) return;
+    try {
+      await fetch(`${this.httpBase}/api/presence`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ workspaceId: this.workspaceId, status, focus }),
+      });
+    } catch {
+      // daemon unreachable — best-effort
+    }
+  }
+
+  // Map a daemon SyncEvent (tagged by `kind`) into an ActivityBus event.
+  _onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (!msg || typeof msg.kind !== 'string') return;
+    if (msg.kind === 'conflict') {
+      this.activityBus.publish({
+        type: 'sync-conflict',
+        workspaceId: msg.workspaceId,
+        path: msg.path,
+        resolution: msg.resolution,
+        conflictingUser: msg.conflictingUser,
+      });
+    } else if (msg.kind === 'fatal') {
+      this.activityBus.publish({
+        type: 'sync-fatal',
+        workspaceId: msg.workspaceId,
+        message: msg.message,
+      });
+    } else if (msg.kind === 'presence') {
+      this.activityBus.publish({
+        type: 'remote-presence',
+        workspaceId: msg.workspaceId,
+        user: msg.user,
+        status: msg.status,
+        focus: msg.focus ?? null,
+      });
+    }
+  }
+}
+
+// Derive the daemon's HTTP origin from its WebSocket event-feed URL.
+function httpBaseFrom(wsUrl) {
+  try {
+    const u = new URL(wsUrl);
+    const proto = u.protocol === 'wss:' ? 'https:' : 'http:';
+    return `${proto}//${u.host}`;
+  } catch {
+    return 'http://127.0.0.1:8320';
+  }
+}

package/server/src/fs.mjs

@@ -0,0 +1,136 @@
+// Workspace file tree + read endpoints. Read-only for v1.
+// Collapsed-by-default surface per AR-16; the agent does the editing.
+
+import fs from 'node:fs/promises';
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+const IGNORED_DIRS = new Set([
+  'node_modules',
+  '.git',
+  '.next',
+  'dist',
+  'build',
+  'target',
+  '.turbo',
+  '.parcel-cache',
+  '.vite',
+  'coverage',
+  '.cache',
+  '.pnpm-store',
+  '.yarn',
+  '.idea',
+  '.vscode',
+]);
+
+const MAX_TREE_ENTRIES = 5000;
+const MAX_FILE_BYTES = 512 * 1024; // 512 KB read cap
+
+export function isInside(parent, child) {
+  const rel = path.relative(parent, child);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+export function safeResolve(workspaceDir, requested) {
+  if (!requested || requested === '/' || requested === '') return workspaceDir;
+  const cleaned = requested.replace(/\\/g, '/').replace(/^\/+/, '');
+  const resolved = path.resolve(workspaceDir, cleaned);
+  if (resolved === workspaceDir || isInside(workspaceDir, resolved)) {
+    return resolved;
+  }
+  return null;
+}
+
+export async function listDir(workspaceDir, requested = '') {
+  const target = safeResolve(workspaceDir, requested);
+  if (!target) throw new Error('outside workspace');
+  let entries;
+  try {
+    entries = await fs.readdir(target, { withFileTypes: true });
+  } catch (e) {
+    if (e.code === 'ENOTDIR') return null;
+    if (e.code === 'ENOENT') return [];
+    throw e;
+  }
+  return entries
+    .filter((entry) => !(entry.isDirectory() && IGNORED_DIRS.has(entry.name)))
+    .map((entry) => ({
+      name: entry.name,
+      type: entry.isDirectory() ? 'dir' : entry.isFile() ? 'file' : 'other',
+      path: path.relative(workspaceDir, path.join(target, entry.name)).replace(/\\/g, '/'),
+    }))
+    .sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+}
+
+export async function readFile(workspaceDir, requested) {
+  const target = safeResolve(workspaceDir, requested);
+  if (!target) throw new Error('outside workspace');
+  const stat = await fs.stat(target);
+  if (stat.isDirectory()) throw new Error('is a directory');
+  if (stat.size > MAX_FILE_BYTES) {
+    const fd = await fs.open(target, 'r');
+    try {
+      const buf = Buffer.alloc(MAX_FILE_BYTES);
+      await fd.read(buf, 0, MAX_FILE_BYTES, 0);
+      return { content: buf.toString('utf8'), truncated: true, size: stat.size };
+    } finally {
+      await fd.close();
+    }
+  }
+  const content = await fs.readFile(target, 'utf8');
+  return { content, truncated: false, size: stat.size };
+}
+
+export async function fullTree(workspaceDir, maxDepth = 3) {
+  let count = 0;
+  async function walk(dir, depth) {
+    if (depth > maxDepth || count > MAX_TREE_ENTRIES) return [];
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+      if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue;
+      count += 1;
+      if (count > MAX_TREE_ENTRIES) break;
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(workspaceDir, full).replace(/\\/g, '/');
+      const node = {
+        name: entry.name,
+        type: entry.isDirectory() ? 'dir' : 'file',
+        path: rel,
+      };
+      if (entry.isDirectory()) {
+        node.children = await walk(full, depth + 1);
+      }
+      out.push(node);
+    }
+    return out.sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  return walk(workspaceDir, 0);
+}
+
+export function workspaceSummary(workspaceDir) {
+  try {
+    const stat = statSync(workspaceDir);
+    if (!stat.isDirectory()) return null;
+    return {
+      path: workspaceDir,
+      name: path.basename(workspaceDir),
+      exists: true,
+      hasClaudeMd: existsSync(path.join(workspaceDir, 'CLAUDE.md')),
+      hasWildInbox: existsSync(path.join(workspaceDir, '.wild', 'inbox.md')),
+    };
+  } catch {
+    return { path: workspaceDir, name: path.basename(workspaceDir), exists: false };
+  }
+}

package/server/src/inbox.mjs

@@ -0,0 +1,81 @@
+// Component System inbox surfacing.
+// When `.wild/inbox.md` exists or changes, emit notifications.
+// Drives the "I noticed you imported X — want me to walk integration?" cue in chat.
+
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import { EventEmitter } from 'node:events';
+
+export class InboxWatcher extends EventEmitter {
+  constructor(workspaceDir) {
+    super();
+    this.workspaceDir = workspaceDir;
+    this.inboxPath = path.join(workspaceDir, '.wild', 'inbox.md');
+    this.installedPath = path.join(workspaceDir, '.wild', 'installed.json');
+    this.watcher = null;
+  }
+
+  start() {
+    this.watcher = chokidar.watch(
+      [this.inboxPath, this.installedPath, path.join(this.workspaceDir, '.wild', 'imports')],
+      {
+        ignoreInitial: false,
+        persistent: true,
+        depth: 3,
+        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 100 },
+      },
+    );
+    this.watcher.on('add', () => this._refresh('add'));
+    this.watcher.on('change', () => this._refresh('change'));
+    this.watcher.on('unlink', () => this._refresh('unlink'));
+    return this;
+  }
+
+  async _refresh(kind) {
+    const snapshot = await this.snapshot();
+    this.emit('change', { kind, snapshot });
+  }
+
+  async snapshot() {
+    const out = {
+      hasInbox: existsSync(this.inboxPath),
+      inboxContent: '',
+      installed: {},
+      imports: [],
+    };
+    if (out.hasInbox) {
+      try {
+        out.inboxContent = await fs.readFile(this.inboxPath, 'utf8');
+      } catch {
+        out.inboxContent = '';
+      }
+    }
+    if (existsSync(this.installedPath)) {
+      try {
+        const raw = await fs.readFile(this.installedPath, 'utf8');
+        out.installed = JSON.parse(raw);
+      } catch {
+        out.installed = {};
+      }
+    }
+    const importsDir = path.join(this.workspaceDir, '.wild', 'imports');
+    if (existsSync(importsDir)) {
+      try {
+        const entries = await fs.readdir(importsDir, { withFileTypes: true });
+        out.imports = entries
+          .filter((e) => e.isDirectory())
+          .map((e) => e.name);
+      } catch {
+        out.imports = [];
+      }
+    }
+    return out;
+  }
+
+  stop() {
+    if (this.watcher) this.watcher.close();
+    this.watcher = null;
+  }
+}