openbot 0.4.7 → 0.5.4

package/dist/plugins/todo/service.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_CHANNELS_DIR, getBaseDir, resolvePath } from '../../app/config.js';
+export const MAX_TODO_ITEMS = 20;
+const TODO_STATUSES = new Set([
+    'pending',
+    'in_progress',
+    'completed',
+    'cancelled',
+]);
+const getThreadDir = (channelId, threadId) => {
+    const base = resolvePath(path.join(getBaseDir(), DEFAULT_CHANNELS_DIR, channelId));
+    return path.join(base, 'threads', threadId);
+};
+const getTodosPath = (channelId, threadId) => path.join(getThreadDir(channelId, threadId), 'todos.json');
+const emptyList = () => ({
+    items: [],
+    updatedAt: new Date().toISOString(),
+});
+/**
+ * Validate and normalize a todo list write. Throws on invalid input.
+ * Enforces: non-empty content, known statuses, unique ids, max size,
+ * and at most one `in_progress` item.
+ */
+export function validateTodoItems(items) {
+    if (!Array.isArray(items)) {
+        throw new Error('todos must be an array');
+    }
+    if (items.length > MAX_TODO_ITEMS) {
+        throw new Error(`At most ${MAX_TODO_ITEMS} todos allowed`);
+    }
+    const seen = new Set();
+    let inProgressCount = 0;
+    const normalized = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('Each todo must be an object');
+        }
+        const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+        const content = typeof raw.content === 'string' ? raw.content.trim() : '';
+        const status = raw.status;
+        if (!id)
+            throw new Error('Each todo requires a non-empty id');
+        if (!content)
+            throw new Error(`Todo "${id}" requires non-empty content`);
+        if (!TODO_STATUSES.has(status)) {
+            throw new Error(`Todo "${id}" has invalid status "${String(status)}"; expected pending|in_progress|completed|cancelled`);
+        }
+        if (seen.has(id))
+            throw new Error(`Duplicate todo id "${id}"`);
+        seen.add(id);
+        if (status === 'in_progress')
+            inProgressCount += 1;
+        normalized.push({ id, content, status: status });
+    }
+    if (inProgressCount > 1) {
+        throw new Error('At most one todo may be in_progress');
+    }
+    return normalized;
+}
+export const todoService = {
+    getTodos: async (args) => {
+        const filePath = getTodosPath(args.channelId, args.threadId);
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const items = Array.isArray(parsed.items) ? parsed.items : [];
+            return {
+                items,
+                updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+            };
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return emptyList();
+            throw e;
+        }
+    },
+    writeTodos: async (args) => {
+        const items = validateTodoItems(args.items);
+        const list = {
+            items,
+            updatedAt: new Date().toISOString(),
+        };
+        const threadDir = getThreadDir(args.channelId, args.threadId);
+        await fs.mkdir(threadDir, { recursive: true });
+        const filePath = getTodosPath(args.channelId, args.threadId);
+        const tmp = `${filePath}.tmp`;
+        await fs.writeFile(tmp, `${JSON.stringify(list, null, 2)}\n`, 'utf-8');
+        await fs.rename(tmp, filePath);
+        return list;
+    },
+};

package/dist/plugins/ui/index.js

@@ -36,7 +36,14 @@ export const uiPlugin = {
                     id: z.string(),
                     label: z.string(),
                     description: z.string().optional(),
-                    status: z.enum(['pending', 'in_progress', 'done', 'error', 'cancelled']).optional(),
+                    status: z
+                        .string()
+                        .optional()
+                        .describe('Status label shown on the item (e.g. "Pending", "Shipped").'),
+                    statusVariant: z
+                        .enum(['default', 'success', 'warning', 'danger', 'info'])
+                        .optional()
+                        .describe('Semantic hint for status badge coloring in the client.'),
                     metadata: z.record(z.string(), z.any()).optional()
                 })).optional().describe('Required for kind="list". List of items to display.'),
                 submitLabel: z.string().optional().describe('Label for the primary action button (e.g. "Submit", "Save").')

package/dist/services/plugins/model-registry.js

@@ -0,0 +1,101 @@
+import { DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig, } from '../../app/config.js';
+import { isCloudMode } from '../../app/cloud-mode.js';
+let cachedRegistry = null;
+let cacheUrl = null;
+function getRegistryUrl() {
+    const { marketplaceRegistryUrl } = loadConfig();
+    return marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
+}
+export async function resolveModelRegistry() {
+    const url = getRegistryUrl();
+    if (cachedRegistry && cacheUrl === url)
+        return cachedRegistry;
+    try {
+        const res = await fetch(url, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok) {
+            throw new Error(`Registry HTTP ${res.status} ${res.statusText}`);
+        }
+        cachedRegistry = (await res.json());
+        cacheUrl = url;
+        return cachedRegistry;
+    }
+    catch (err) {
+        console.warn('[model-registry] fetch failed:', err instanceof Error ? err.message : err);
+        return { providers: {} };
+    }
+}
+export function listModelOptionsFromRegistry(registry) {
+    const providers = registry.providers ?? {};
+    const out = [];
+    for (const [providerId, provider] of Object.entries(providers)) {
+        for (const model of provider.models ?? []) {
+            out.push({
+                value: `${providerId}/${model.id}`,
+                label: `${provider.label} — ${model.label}`,
+                description: model.description,
+                provider: providerId,
+            });
+        }
+    }
+    return out;
+}
+export async function listRegistryModelOptions() {
+    const registry = await resolveModelRegistry();
+    return listModelOptionsFromRegistry(registry);
+}
+export function listApiKeyProvidersFromRegistry(registry) {
+    const providers = registry.providers ?? {};
+    return Object.entries(providers).map(([id, provider]) => ({
+        id,
+        label: provider.label,
+    }));
+}
+function pickDefaultModelValue(options) {
+    if (options.length === 0)
+        return undefined;
+    const values = options.map((option) => option.value);
+    const preferred = isCloudMode()
+        ? values.find((value) => value.startsWith('openbot/'))
+        : values.find((value) => value.startsWith('openai/'));
+    return preferred ?? values[0];
+}
+export function enrichOpenbotPluginDescriptor(descriptor, modelOptions) {
+    if (descriptor.id !== 'openbot' || !descriptor.configSchema)
+        return descriptor;
+    const modelProperty = descriptor.configSchema.properties.model;
+    if (!modelProperty)
+        return descriptor;
+    const values = modelOptions.map((option) => option.value);
+    const staticDefault = typeof modelProperty.default === 'string' ? modelProperty.default : undefined;
+    const defaultModel = staticDefault && values.includes(staticDefault)
+        ? staticDefault
+        : pickDefaultModelValue(modelOptions) ?? staticDefault;
+    const nextModelProperty = {
+        ...modelProperty,
+        description: 'Model from the hosted marketplace registry.',
+    };
+    if (values.length > 0) {
+        nextModelProperty.enum = values;
+        nextModelProperty.options = modelOptions.map((option) => ({
+            label: option.label,
+            value: option.value,
+            description: option.description,
+        }));
+    }
+    if (defaultModel) {
+        nextModelProperty.default = defaultModel;
+    }
+    return {
+        ...descriptor,
+        configSchema: {
+            ...descriptor.configSchema,
+            properties: {
+                ...descriptor.configSchema.properties,
+                model: nextModelProperty,
+            },
+        },
+    };
+}

package/dist/services/plugins/registry.js

@@ -6,10 +6,12 @@ import { bashPlugin } from '../../plugins/bash/index.js';
 import { storagePlugin } from '../../plugins/storage/index.js';
 import { approvalPlugin } from '../../plugins/approval/index.js';
 import { memoryPlugin } from '../../plugins/memory/index.js';
+import { todoPlugin } from '../../plugins/todo/index.js';
 import { delegationPlugin } from '../../plugins/delegation/index.js';
 import { uiPlugin } from '../../plugins/ui/index.js';
 import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import { previewPlugin } from '../../plugins/preview/index.js';
+import { DEFAULT_PLUGINS_DIR, getBaseDir } from '../../app/config.js';
 import { invalidatePlugin as clearResolvedPluginEntry, loadedCommunityPlugins, resolvedPluginCache, } from './plugin-cache.js';
 let pluginsDir = null;
 const BUILT_IN = {
@@ -18,9 +20,11 @@ const BUILT_IN = {
     [storagePlugin.id]: storagePlugin,
     [approvalPlugin.id]: approvalPlugin,
     [memoryPlugin.id]: memoryPlugin,
+    [todoPlugin.id]: todoPlugin,
     [delegationPlugin.id]: delegationPlugin,
     [uiPlugin.id]: uiPlugin,
     [pluginManagerPlugin.id]: pluginManagerPlugin,
+    [previewPlugin.id]: previewPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {
@@ -51,9 +55,7 @@ export function initPlugins(dir) {
         pluginsDir = dir;
     }
     else {
-        const config = loadConfig();
-        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-        pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
+        pluginsDir = path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
     }
 }
 /**

package/dist/services/plugins/service.js

@@ -3,7 +3,7 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig, resolvePath, } from '../../app/config.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_MARKETPLACE_REGISTRY_URL, getBaseDir, loadConfig, } from '../../app/config.js';
 import { invalidatePlugin } from './plugin-cache.js';
 const execAsync = promisify(exec);
 const DEFAULT_MARKETPLACE_AGENTS = [];
@@ -136,11 +136,7 @@ export async function resolveMarketplaceAgentList() {
     const registry = await resolveMarketplaceRegistry();
     return registry.agents;
 }
-const getPluginsDir = () => {
-    const config = loadConfig();
-    const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-    return path.join(baseDir, DEFAULT_PLUGINS_DIR);
-};
+const getPluginsDir = () => path.join(getBaseDir(), DEFAULT_PLUGINS_DIR);
 /**
  * Lifecycle for community-built plugins distributed via npm.
  * Each plugin is installed to `<plugins>/<npm-name>/` and is identified

package/docs/agents.md

@@ -36,8 +36,8 @@ A runtime plugin is one that handles `agent:invoke` (the LLM loop). Without
 one, the agent will not respond to user input. Built-in runtime plugins:
 
 - `openbot` — the standard, opinionated OpenBot agent runtime. It is
-  **batteries-included** and provides inbuilt tools (bash, memory, storage,
-  delegation, and approval).
+  **batteries-included** and provides inbuilt tools (bash, memory, todo,
+  storage, delegation, and approval).
 - `claude-code` — runs Claude inside the Claude Agent SDK with its own tools.
 - `gemini-cli` — spawns Google's `gemini` CLI in headless mode.
 
@@ -66,6 +66,24 @@ On every LLM turn the runtime injects matching memories into the system prompt
 via the `MemoryProvider` in the context engine, so the model treats remembered
 facts as ground truth without needing to call `recall` first.
 
+## Todos
+
+The `todo` plugin gives agents `todo_write` and `todo_read` for thread-scoped
+multi-step task tracking. The list is stored at
+`~/.openbot/channels/<channelId>/threads/<threadId>/todos.json`.
+
+Rules enforced by the runtime:
+
+- At most 20 items
+- At most one item may be `in_progress`
+- Each `todo_write` replaces the full list
+
+On every LLM turn the current list is injected into context as `## TODOS`, so
+the model usually does not need `todo_read`. Each successful `todo_write` also
+emits a `client:ui:widget` list (`widgetId` `todos:<runId>`, stable for the
+agent run so multiple `todo_write` calls update one widget), and both tools return
+`data.output` for model feedback.
+
 ## Installing community agents
 
 Marketplace entries reference plugin ids (built-in or npm package names).

package/docs/architecture.md

@@ -5,7 +5,7 @@ OpenBot is an orchestration platform built on a modular, event-driven architectu
 ## Core Components
 
 ### 1. Orchestrator & routing
-The orchestrator is the execution entry point for agent work: it normalizes incoming events, runs the queue processor (todo-driven assignees), builds per-agent Melony runtimes, and streams emitted events back to callers (for example storage and SSE). Routing across the agent network uses:
+The orchestrator is the execution entry point for agent work: it normalizes incoming events, builds per-agent Melony runtimes, and streams emitted events back to callers (for example storage and SSE). Routing across the agent network uses:
 
 1. **Command Prefix** — Explicit delegation to a specific agent (e.g., `/os list files`).
 2. **DM context** — Direct communication with a specific agent.

package/docs/plugins.md

@@ -39,6 +39,14 @@ same agent into a single map and passes it to every plugin via `context.tools`.
 Runtime plugins read it; tool plugins ignore it. First plugin wins on tool
 name collisions.
 
+### Tool results
+
+When a tool handler finishes, yield `action:<tool>:result` with
+`data.output: string`. The OpenBot runtime feeds that string back into the
+model as the tool result (`history.ts`). Structured fields (e.g. `list`,
+`success`) are fine alongside it, but without `output` the model only sees
+`"No output"`.
+
 ## Built-in plugins
 
 | Id              | Role       | Notes                                                     |
@@ -49,6 +57,7 @@ name collisions.
 | `bash`          | Tool       | `bash` (inbuilt in `openbot`)                             |
 | `storage`       | Tool       | `create_channel`, `patch_*`, ... (inbuilt in `openbot`)   |
 | `memory`        | Tool       | `remember`, `recall`, `forget` (inbuilt in `openbot`)     |
+| `todo`          | Tool       | `todo_write`, `todo_read` (inbuilt in `openbot`)          |
 | `plugin-manager`| Infra      | Marketplace list, npm plugin install/uninstall, agent install |
 
 ## Batteries-included: `openbot` runtime
@@ -58,6 +67,7 @@ to be isolated and self-contained, providing a core ecosystem of inbuilt tools:
 
 - **Bash**: Stateful system tasks and file operations.
 - **Memory**: Long-term durable fact storage.
+- **Todo**: Thread-scoped multi-step task checklist.
 - **Storage**: Channel and thread management.
 - **Delegation**: Calling upon other specialized agents.
 - **Approval**: Gating protected actions behind UI confirmation.
@@ -71,7 +81,7 @@ plugins:
     config:
       model: openai/gpt-4o-mini
       approval:
-        actions: [action:bash, action:create_channel]
+        actions: [action:shell_exec, action:create_channel]
 ```
 
 A community plugin is just an npm package whose default export matches the
@@ -90,11 +100,11 @@ On first use OpenBot installs the package into
 
 ## Approval plugin
 
-The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:bash`.
+The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:shell_exec`.
 
 ```yaml
 plugins:
   - id: approval
     config:
-      actions: [action:bash]
+      actions: [action:shell_exec]
 ```

package/docs/templates/AGENT.example.md

@@ -28,7 +28,7 @@ plugins:
   - id: storage
   - id: approval
     config:
-      actions: [action:bash]
+      actions: [action:shell_exec]
 ---
 
 <!--

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.4.7",
+  "version": "0.5.4",
   "private": false,
   "type": "module",
   "engines": {
@@ -9,7 +9,9 @@
   "scripts": {
     "dev": "tsx watch src/app/cli.ts start",
     "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
-    "start": "node dist/app/cli.js start"
+    "start": "node dist/app/cli.js start",
+    "format": "prettier --write .",
+    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.4"
   },
   "bin": {
     "openbot": "./dist/app/cli.js"
@@ -34,6 +36,7 @@
     "@types/express": "^4.17.21",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.1",
+    "prettier": "^3.4.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/src/app/bootstrap.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  CONFIG_FILE,
+  DEFAULT_AGENTS_DIR,
+  DEFAULT_CHANNELS_DIR,
+  DEFAULT_PLUGINS_DIR,
+  getBaseDir,
+  getChannelsWorkspaceRoot,
+  getConfigDir,
+  type OpenBotconfig,
+} from './config.js';
+
+/** Ensure data directories and a minimal config exist (first boot on a Fly volume). */
+export async function bootstrap(): Promise<void> {
+  const baseDir = getBaseDir();
+  const configDir = getConfigDir();
+
+  await fs.mkdir(path.join(baseDir, DEFAULT_AGENTS_DIR), { recursive: true });
+  await fs.mkdir(path.join(baseDir, DEFAULT_PLUGINS_DIR), { recursive: true });
+  await fs.mkdir(path.join(baseDir, DEFAULT_CHANNELS_DIR), { recursive: true });
+  await fs.mkdir(getChannelsWorkspaceRoot(), { recursive: true });
+  await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
+
+  const configPath = path.join(configDir, CONFIG_FILE);
+  try {
+    await fs.access(configPath);
+  } catch {
+    const initial: OpenBotconfig = { baseDir };
+
+    const publicUrl = process.env.OPENBOT_PUBLIC_URL?.trim();
+    if (publicUrl) {
+      initial.publicUrl = publicUrl.replace(/\/$/, '');
+    }
+
+    const workspaceDir = process.env.OPENBOT_CHANNELS_WORKSPACE_DIR?.trim();
+    if (workspaceDir) {
+      initial.channelsWorkspaceDir = getChannelsWorkspaceRoot();
+    }
+
+    await fs.writeFile(configPath, JSON.stringify(initial, null, 2), { mode: 0o600 });
+  }
+}

package/src/app/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { bootstrap } from './bootstrap.js';
 import { startServer } from './server.js';
 
 const program = new Command();
@@ -25,13 +26,14 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.4.7');
+program.name('openbot').description('OpenBot CLI').version('0.5.4');
 
 program
   .command('start')
   .description('Start the OpenBot harness')
   .option('-p, --port <number>', 'Port to listen on')
   .action(async (options) => {
+    await bootstrap();
     await startServer(options);
   });
 

package/src/app/cloud-mode.ts

@@ -0,0 +1,41 @@
+import { ORCHESTRATOR_AGENT_ID } from './agent-ids.js';
+
+/** Platform-managed OpenBot (Fly + integrations proxy). Self-hosted when unset. */
+export const isCloudMode = (): boolean => process.env.OPENBOT_CLOUD_MODE === '1';
+
+/** Platform-managed coordinator model for cloud workspaces. */
+export const COORDINATOR_MODEL = 'openbot/coordinator-1';
+
+/** Default cloud system agent model. */
+export const CLOUD_SYSTEM_MODEL = COORDINATOR_MODEL;
+
+export interface CloudIntegrationsConfig {
+  baseUrl: string;
+  token: string;
+}
+
+export function getCloudIntegrationsConfig(): CloudIntegrationsConfig | null {
+  if (!isCloudMode()) return null;
+
+  const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
+  const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
+  if (!baseUrl || !token) return null;
+
+  return { baseUrl: baseUrl.replace(/\/$/, ''), token };
+}
+
+export function isCloudSystemAgent(agentId: string): boolean {
+  return isCloudMode() && agentId === ORCHESTRATOR_AGENT_ID;
+}
+
+export function resolveCloudSystemModel(configModel: string | undefined): string {
+  return configModel?.trim() || COORDINATOR_MODEL;
+}
+
+export function assertCloudSystemAgentPluginsMutable(
+  agentId: string,
+  plugins: unknown,
+): void {
+  void agentId;
+  void plugins;
+}

package/src/app/config.ts

@@ -8,6 +8,8 @@ export interface OpenBotconfig {
   model?: string;
   image?: string;
   baseDir?: string;
+  /** Parent directory for per-channel working directories (user-facing workspace). */
+  channelsWorkspaceDir?: string;
   port?: number;
   /**
    * Overrides the default public marketplace registry URL. If omitted or blank,
@@ -41,52 +43,102 @@ export function resolvePath(p: string) {
   return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
 
+function readConfigFile(configDir: string): OpenBotconfig {
+  const configPath = path.join(configDir, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8')) as OpenBotconfig;
+    } catch (error) {
+      console.error(`Warning: Failed to parse config at ${configPath}`, error);
+    }
+  }
+  return {};
+}
+
+/** Directory that holds `config.json` (env `OPENBOT_BASE_DIR` or `~/.openbot`). */
+export function getConfigDir(): string {
+  const envBase = process.env.OPENBOT_BASE_DIR?.trim();
+  if (envBase) {
+    return resolvePath(envBase);
+  }
+  return path.join(os.homedir(), '.openbot');
+}
+
+/** Resolved OpenBot data root (agents, channels, plugins, variables). */
+export function getBaseDir(): string {
+  const envBase = process.env.OPENBOT_BASE_DIR?.trim();
+  if (envBase) {
+    return resolvePath(envBase);
+  }
+  const fileConfig = readConfigFile(getConfigDir());
+  return resolvePath(fileConfig.baseDir || DEFAULT_BASE_DIR);
+}
+
+/** Resolved parent directory for per-channel workspace folders. */
+export function getChannelsWorkspaceRoot(): string {
+  const env = process.env.OPENBOT_CHANNELS_WORKSPACE_DIR?.trim();
+  if (env) {
+    return resolvePath(env);
+  }
+  const fileConfig = readConfigFile(getConfigDir());
+  if (fileConfig.channelsWorkspaceDir) {
+    return resolvePath(fileConfig.channelsWorkspaceDir);
+  }
+  return resolvePath(DEFAULT_CHANNELS_WORKSPACE_DIR);
+}
+
 /** Default absolute cwd for a channel when none is provided at creation time. */
 export function getDefaultChannelCwd(channelId: string): string {
   const id = channelId.trim();
   if (!id) {
     throw new Error('channelId is required');
   }
-  return resolvePath(`${DEFAULT_CHANNELS_WORKSPACE_DIR}/${id}`);
+  return path.join(getChannelsWorkspaceRoot(), id);
 }
 
 export function loadConfig(): OpenBotconfig {
-  const configPath = path.join(os.homedir(), '.openbot', CONFIG_FILE);
-  if (fs.existsSync(configPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    } catch (error) {
-      console.error(`Warning: Failed to parse config at ${configPath}`, error);
-    }
+  const fileConfig = readConfigFile(getConfigDir());
+  const merged: OpenBotconfig = { ...fileConfig };
+
+  merged.baseDir = getBaseDir();
+
+  const envPublicUrl = process.env.OPENBOT_PUBLIC_URL?.trim();
+  if (envPublicUrl) {
+    merged.publicUrl = envPublicUrl.replace(/\/$/, '');
+  } else if (merged.publicUrl) {
+    merged.publicUrl = merged.publicUrl.replace(/\/$/, '');
   }
-  return {};
+
+  merged.channelsWorkspaceDir = getChannelsWorkspaceRoot();
+
+  const envPort = process.env.PORT?.trim();
+  if (envPort && !Number.isNaN(Number(envPort))) {
+    merged.port = Number(envPort);
+  }
+
+  return merged;
 }
 
 export function saveConfig(config: Partial<OpenBotconfig>) {
-  const configDir = resolvePath(DEFAULT_BASE_DIR);
+  const configDir = getConfigDir();
   const configPath = path.join(configDir, CONFIG_FILE);
 
   if (!fs.existsSync(configDir)) {
     fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
   }
 
-  const currentConfig = loadConfig();
+  const currentConfig = readConfigFile(configDir);
   const newConfig = { ...currentConfig, ...config };
 
   fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), { mode: 0o600 });
 }
 
 export function isConfigured(): boolean {
-  const configPath = path.join(resolvePath(DEFAULT_BASE_DIR), CONFIG_FILE);
-  return fs.existsSync(configPath);
+  return fs.existsSync(path.join(getConfigDir(), CONFIG_FILE));
 }
 
 export function loadVariables(): { version: number; variables: StoredVariable[] } {
-  const config = loadConfig();
-  const variablesPath = path.join(
-    resolvePath(config.baseDir || DEFAULT_BASE_DIR),
-    VARIABLES_FILE,
-  );
+  const variablesPath = path.join(getBaseDir(), VARIABLES_FILE);
   if (fs.existsSync(variablesPath)) {
     return JSON.parse(fs.readFileSync(variablesPath, 'utf-8')) as {
       version: number;
@@ -94,4 +146,4 @@ export function loadVariables(): { version: number; variables: StoredVariable[]
     };
   }
   return { version: 1, variables: [] };
-}
+}