@dobby.ai/dobby 0.1.0

package/src/cli/shared/config-io.ts

@@ -0,0 +1,277 @@
+import { existsSync, readFileSync } from "node:fs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { homedir } from "node:os";
+import { loadGatewayConfig } from "../../core/routing.js";
+import type { RawGatewayConfig } from "./config-types.js";
+
+/**
+ * Default config file path used by all CLI commands.
+ */
+export const DEFAULT_CONFIG_PATH = resolve(homedir(), ".dobby", "gateway.json");
+
+/**
+ * Expands "~" prefixed paths to the current user's home directory.
+ */
+function expandHome(value: string): string {
+  if (value === "~") {
+    return homedir();
+  }
+
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return resolve(homedir(), value.slice(2));
+  }
+
+  return value;
+}
+
+type ConfigPathSource = "env" | "repo" | "default";
+
+interface ConfigPathResolutionInput {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+interface ResolvedConfigPathInfo {
+  path: string;
+  source: ConfigPathSource;
+}
+
+/**
+ * Returns true when a directory looks like the dobby repository root.
+ */
+function isDobbyRepoRoot(candidateDir: string): boolean {
+  const packageJsonPath = resolve(candidateDir, "package.json");
+  const repoConfigPath = resolve(candidateDir, "config", "gateway.json");
+  const localExtensionsScriptPath = resolve(candidateDir, "scripts", "local-extensions.mjs");
+
+  if (!existsSync(packageJsonPath) || !existsSync(repoConfigPath) || !existsSync(localExtensionsScriptPath)) {
+    return false;
+  }
+
+  try {
+    const packageJsonRaw = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(packageJsonRaw) as { name?: unknown };
+    return parsed.name === "dobby";
+  } catch {
+    return false;
+  }
+}
+
+function resolveConfigBaseDir(configPath: string): string {
+  const absoluteConfigPath = resolve(configPath);
+  const configDir = dirname(absoluteConfigPath);
+  const repoRoot = dirname(configDir);
+
+  if (absoluteConfigPath === resolve(repoRoot, "config", "gateway.json") && isDobbyRepoRoot(repoRoot)) {
+    return repoRoot;
+  }
+
+  return configDir;
+}
+
+/**
+ * Scans current directory and ancestors to find a local dobby repo config path.
+ */
+function findDobbyRepoConfigPath(startDir: string): string | null {
+  let currentDir = resolve(startDir);
+
+  while (true) {
+    if (isDobbyRepoRoot(currentDir)) {
+      return resolve(currentDir, "config", "gateway.json");
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+/**
+ * Resolves config path source by priority: env override -> local repo -> default home path.
+ */
+function resolveConfigPathInfo(input?: ConfigPathResolutionInput): ResolvedConfigPathInfo {
+  const env = input?.env ?? process.env;
+  const cwd = input?.cwd ?? process.cwd();
+  const rawOverride = env.DOBBY_CONFIG_PATH;
+  const override = typeof rawOverride === "string" ? rawOverride.trim() : "";
+
+  if (override.length > 0) {
+    const expanded = expandHome(override);
+    return {
+      path: isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded),
+      source: "env",
+    };
+  }
+
+  const localRepoConfigPath = findDobbyRepoConfigPath(cwd);
+  if (localRepoConfigPath) {
+    return {
+      path: localRepoConfigPath,
+      source: "repo",
+    };
+  }
+
+  return {
+    path: DEFAULT_CONFIG_PATH,
+    source: "default",
+  };
+}
+
+/**
+ * Resolves config path with dev-friendly detection and env override support.
+ */
+export function resolveConfigPath(input?: ConfigPathResolutionInput): string {
+  return resolveConfigPathInfo(input).path;
+}
+
+/**
+ * Formats a user-facing init command hint for missing-config errors.
+ */
+function initCommandHint(): string {
+  return "dobby init";
+}
+
+/**
+ * Resolves data.rootDir into an absolute path using config-file-relative semantics.
+ */
+export function resolveDataRootDir(configPath: string, rawConfig: RawGatewayConfig): string {
+  const absoluteConfigPath = resolve(configPath);
+  const baseDir = resolveConfigBaseDir(absoluteConfigPath);
+  const rawRootDir = typeof rawConfig.data?.rootDir === "string" && rawConfig.data.rootDir.trim().length > 0
+    ? rawConfig.data.rootDir
+    : "./data";
+
+  const expanded = expandHome(rawRootDir);
+  if (isAbsolute(expanded)) {
+    return resolve(expanded);
+  }
+
+  return resolve(baseDir, expanded);
+}
+
+/**
+ * Checks whether a file exists without throwing for missing paths.
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reads and parses the raw JSON config file.
+ */
+export async function readRawConfig(configPath: string): Promise<RawGatewayConfig | null> {
+  const absolutePath = resolve(configPath);
+  if (!(await fileExists(absolutePath))) {
+    return null;
+  }
+
+  const raw = await readFile(absolutePath, "utf-8");
+  const parsed = JSON.parse(raw) as unknown;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Config at '${absolutePath}' must be a JSON object`);
+  }
+
+  return parsed as RawGatewayConfig;
+}
+
+/**
+ * Writes config content atomically via temp file + rename.
+ */
+async function writeAtomic(configPath: string, content: string): Promise<void> {
+  const absolutePath = resolve(configPath);
+  const configDir = dirname(absolutePath);
+  await mkdir(configDir, { recursive: true });
+
+  const tempPath = `${absolutePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await writeFile(tempPath, content, "utf-8");
+  await rename(tempPath, absolutePath);
+}
+
+/**
+ * Serializes and writes the config file with normalized JSON formatting.
+ */
+export async function writeRawConfig(configPath: string, rawConfig: RawGatewayConfig): Promise<void> {
+  const payload = `${JSON.stringify(rawConfig, null, 2)}\n`;
+  await writeAtomic(configPath, payload);
+}
+
+/**
+ * Creates a timestamped backup beside the target config file.
+ */
+export async function backupConfig(configPath: string): Promise<string | null> {
+  const absolutePath = resolve(configPath);
+  if (!(await fileExists(absolutePath))) {
+    return null;
+  }
+
+  const content = await readFile(absolutePath, "utf-8");
+  const backupPath = `${absolutePath}.bak-${Date.now()}`;
+  await writeFile(backupPath, content, "utf-8");
+  return backupPath;
+}
+
+/**
+ * Writes config, validates with loadGatewayConfig, and rolls back on any failure.
+ */
+export async function writeConfigWithValidation(
+  configPath: string,
+  rawConfig: RawGatewayConfig,
+  options?: {
+    validate?: boolean;
+    createBackup?: boolean;
+  },
+): Promise<{ backupPath: string | null }> {
+  const absolutePath = resolve(configPath);
+  const validate = options?.validate !== false;
+
+  const previousExists = await fileExists(absolutePath);
+  const previousContent = previousExists ? await readFile(absolutePath, "utf-8") : null;
+  const backupPath = options?.createBackup ? await backupConfig(absolutePath) : null;
+
+  try {
+    await writeRawConfig(absolutePath, rawConfig);
+    if (!validate) {
+      return { backupPath };
+    }
+
+    await loadGatewayConfig(absolutePath);
+    return { backupPath };
+  } catch (error) {
+    if (previousContent === null) {
+      await rm(absolutePath, { force: true });
+    } else {
+      await writeAtomic(absolutePath, previousContent);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Reads config and throws a user-oriented error when the file is missing.
+ */
+export async function requireRawConfig(configPath: string): Promise<RawGatewayConfig> {
+  const raw = await readRawConfig(configPath);
+  if (!raw) {
+    const resolvedConfigPath = resolve(configPath);
+    const currentResolution = resolveConfigPathInfo();
+    let sourceHint = "";
+    if (resolvedConfigPath === currentResolution.path && currentResolution.source === "env") {
+      sourceHint = ` Source: DOBBY_CONFIG_PATH='${process.env.DOBBY_CONFIG_PATH ?? ""}'.`;
+    } else if (resolvedConfigPath === currentResolution.path && currentResolution.source === "repo") {
+      sourceHint = " Source: detected dobby repo, using ./config/gateway.json.";
+    }
+
+    throw new Error(
+      `Config '${resolvedConfigPath}' does not exist.${sourceHint} Run '${initCommandHint()}' first.`,
+    );
+  }
+  return raw;
+}

package/src/cli/shared/config-mutators.ts

@@ -0,0 +1,440 @@
+import type { ExtensionContributionManifest } from "../../core/types.js";
+import type {
+  ContributionInstanceTemplate,
+  ContributionTemplatesByKind,
+  NormalizedGatewayConfig,
+  RawBindingConfig,
+  RawExtensionItemConfig,
+  RawGatewayConfig,
+  RawRouteDefaults,
+  RawRouteProfile,
+} from "./config-types.js";
+
+const DEFAULT_DEDUP_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function asItemMap(value: unknown): Record<string, RawExtensionItemConfig> {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const result: Record<string, RawExtensionItemConfig> = {};
+  for (const [instanceId, raw] of Object.entries(value)) {
+    if (!isRecord(raw) || typeof raw.type !== "string" || raw.type.trim().length === 0) {
+      continue;
+    }
+
+    result[instanceId] = {
+      ...raw,
+      type: raw.type,
+    };
+  }
+
+  return result;
+}
+
+function asAllowList(value: unknown): Array<{ package: string; enabled: boolean }> {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const normalized: Array<{ package: string; enabled: boolean }> = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.package !== "string" || item.package.trim().length === 0) {
+      continue;
+    }
+
+    normalized.push({
+      package: item.package,
+      enabled: item.enabled !== false,
+    });
+  }
+
+  return normalized;
+}
+
+function asRouteDefaults(value: unknown): RawRouteDefaults {
+  if (!isRecord(value)) {
+    return {
+      tools: "full",
+      mentions: "required",
+    };
+  }
+
+  return {
+    ...(typeof value.provider === "string" && value.provider.trim().length > 0 ? { provider: value.provider } : {}),
+    ...(typeof value.sandbox === "string" && value.sandbox.trim().length > 0 ? { sandbox: value.sandbox } : {}),
+    tools: value.tools === "readonly" ? "readonly" : "full",
+    mentions: value.mentions === "optional" ? "optional" : "required",
+  };
+}
+
+function asRoutes(value: unknown): Record<string, RawRouteProfile> {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const normalized: Record<string, RawRouteProfile> = {};
+  for (const [routeId, route] of Object.entries(value)) {
+    if (!isRecord(route) || typeof route.projectRoot !== "string" || route.projectRoot.trim().length === 0) {
+      continue;
+    }
+
+    normalized[routeId] = {
+      ...route,
+      projectRoot: route.projectRoot,
+      ...(route.tools === "readonly" ? { tools: "readonly" as const } : {}),
+      ...(route.mentions === "optional" ? { mentions: "optional" as const } : {}),
+      ...(typeof route.provider === "string" && route.provider.trim().length > 0 ? { provider: route.provider } : {}),
+      ...(typeof route.sandbox === "string" && route.sandbox.trim().length > 0 ? { sandbox: route.sandbox } : {}),
+      ...(typeof route.systemPromptFile === "string" ? { systemPromptFile: route.systemPromptFile } : {}),
+    };
+  }
+
+  return normalized;
+}
+
+function asBindings(value: unknown): Record<string, RawBindingConfig> {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const normalized: Record<string, RawBindingConfig> = {};
+  for (const [bindingId, binding] of Object.entries(value)) {
+    if (!isRecord(binding)) {
+      continue;
+    }
+
+    const rawSource = binding.source;
+    if (
+      typeof binding.connector !== "string"
+      || binding.connector.trim().length === 0
+      || typeof binding.route !== "string"
+      || binding.route.trim().length === 0
+      || !isRecord(rawSource)
+      || (rawSource.type !== "channel" && rawSource.type !== "chat")
+      || typeof rawSource.id !== "string"
+      || rawSource.id.trim().length === 0
+    ) {
+      continue;
+    }
+
+    normalized[bindingId] = {
+      ...binding,
+      connector: binding.connector,
+      route: binding.route,
+      source: {
+        ...rawSource,
+        type: rawSource.type,
+        id: rawSource.id,
+      },
+    };
+  }
+
+  return normalized;
+}
+
+export function ensureGatewayConfigShape(config: RawGatewayConfig): NormalizedGatewayConfig {
+  const normalizedProvidersDefault =
+    typeof config.providers?.default === "string" && config.providers.default.trim().length > 0
+      ? config.providers.default
+      : "";
+  const normalizedSandboxesDefault =
+    typeof config.sandboxes?.default === "string" && config.sandboxes.default.trim().length > 0
+      ? config.sandboxes.default
+      : "host.builtin";
+
+  const routeDefaults = asRouteDefaults(config.routes?.defaults);
+  if (!routeDefaults.provider && normalizedProvidersDefault) {
+    routeDefaults.provider = normalizedProvidersDefault;
+  }
+  if (!routeDefaults.sandbox && normalizedSandboxesDefault) {
+    routeDefaults.sandbox = normalizedSandboxesDefault;
+  }
+
+  return {
+    ...config,
+    extensions: {
+      ...((isRecord(config.extensions) ? config.extensions : {}) as Record<string, unknown>),
+      allowList: asAllowList(config.extensions?.allowList),
+    },
+    providers: {
+      ...((isRecord(config.providers) ? config.providers : {}) as Record<string, unknown>),
+      default: normalizedProvidersDefault,
+      items: asItemMap(config.providers?.items),
+    },
+    connectors: {
+      ...((isRecord(config.connectors) ? config.connectors : {}) as Record<string, unknown>),
+      items: asItemMap(config.connectors?.items),
+    },
+    sandboxes: {
+      ...((isRecord(config.sandboxes) ? config.sandboxes : {}) as Record<string, unknown>),
+      default: normalizedSandboxesDefault,
+      items: asItemMap(config.sandboxes?.items),
+    },
+    routes: {
+      ...((isRecord(config.routes) ? config.routes : {}) as Record<string, unknown>),
+      defaults: routeDefaults,
+      items: asRoutes(config.routes?.items),
+    },
+    bindings: {
+      ...((isRecord(config.bindings) ? config.bindings : {}) as Record<string, unknown>),
+      items: asBindings(config.bindings?.items),
+    },
+    data: {
+      ...((isRecord(config.data) ? config.data : {}) as Record<string, unknown>),
+      rootDir: typeof config.data?.rootDir === "string" && config.data.rootDir.trim().length > 0 ? config.data.rootDir : "./data",
+      dedupTtlMs:
+        typeof config.data?.dedupTtlMs === "number" && Number.isFinite(config.data.dedupTtlMs) && config.data.dedupTtlMs > 0
+          ? config.data.dedupTtlMs
+          : DEFAULT_DEDUP_TTL_MS,
+    },
+  };
+}
+
+export function upsertAllowListPackage(config: RawGatewayConfig, packageName: string, enabled = true): void {
+  const next = ensureGatewayConfigShape(config);
+  const allowList = next.extensions.allowList;
+  const existing = allowList.find((item) => item.package === packageName);
+  if (existing) {
+    existing.enabled = enabled;
+    config.extensions = next.extensions;
+    return;
+  }
+
+  allowList.push({ package: packageName, enabled });
+  config.extensions = {
+    ...next.extensions,
+    allowList,
+  };
+}
+
+function buildTemplateInstanceId(contributionId: string): string {
+  const segments = contributionId.split(".");
+  const suffix = segments.length > 1 ? segments.slice(1).join("-") : contributionId;
+  return `${suffix}.main`;
+}
+
+export function buildContributionTemplates(contributions: ExtensionContributionManifest[]): ContributionTemplatesByKind {
+  const templates: ContributionTemplatesByKind = {
+    providers: [],
+    connectors: [],
+    sandboxes: [],
+  };
+
+  for (const contribution of contributions) {
+    const template: ContributionInstanceTemplate = {
+      id: buildTemplateInstanceId(contribution.id),
+      type: contribution.id,
+      config: {},
+    };
+
+    if (contribution.kind === "provider") {
+      templates.providers.push(template);
+      continue;
+    }
+
+    if (contribution.kind === "connector") {
+      templates.connectors.push(template);
+      continue;
+    }
+
+    templates.sandboxes.push(template);
+  }
+
+  return templates;
+}
+
+function upsertTemplateInstances(
+  items: Record<string, RawExtensionItemConfig>,
+  templates: ContributionInstanceTemplate[],
+): string[] {
+  const byType = new Set(Object.values(items).map((instance) => instance.type));
+  const addedIds: string[] = [];
+
+  for (const template of templates) {
+    if (byType.has(template.type)) {
+      continue;
+    }
+
+    let candidateId = template.id;
+    let suffix = 2;
+    while (items[candidateId]) {
+      candidateId = `${template.id}-${suffix}`;
+      suffix += 1;
+    }
+
+    items[candidateId] = {
+      type: template.type,
+      ...structuredClone(template.config),
+    };
+    byType.add(template.type);
+    addedIds.push(candidateId);
+  }
+
+  return addedIds;
+}
+
+export function applyContributionTemplates(config: RawGatewayConfig, templates: ContributionTemplatesByKind): {
+  providers: string[];
+  connectors: string[];
+  sandboxes: string[];
+} {
+  const next = ensureGatewayConfigShape(config);
+  const providerItems = next.providers.items;
+  const connectorItems = next.connectors.items;
+  const sandboxItems = next.sandboxes.items;
+
+  const added = {
+    providers: upsertTemplateInstances(providerItems, templates.providers),
+    connectors: upsertTemplateInstances(connectorItems, templates.connectors),
+    sandboxes: upsertTemplateInstances(sandboxItems, templates.sandboxes),
+  };
+
+  config.providers = {
+    ...next.providers,
+    items: providerItems,
+  };
+  config.connectors = {
+    ...next.connectors,
+    items: connectorItems,
+  };
+  config.sandboxes = {
+    ...next.sandboxes,
+    items: sandboxItems,
+  };
+
+  return added;
+}
+
+export function upsertProviderInstance(
+  config: RawGatewayConfig,
+  instanceId: string,
+  type: string,
+  instanceConfig: Record<string, unknown>,
+): void {
+  const next = ensureGatewayConfigShape(config);
+  next.providers.items[instanceId] = {
+    type,
+    ...structuredClone(instanceConfig),
+  };
+  config.providers = {
+    ...next.providers,
+    items: next.providers.items,
+  };
+}
+
+export function upsertConnectorInstance(
+  config: RawGatewayConfig,
+  instanceId: string,
+  type: string,
+  instanceConfig: Record<string, unknown>,
+): void {
+  const next = ensureGatewayConfigShape(config);
+  next.connectors.items[instanceId] = {
+    type,
+    ...structuredClone(instanceConfig),
+  };
+  config.connectors = {
+    ...next.connectors,
+    items: next.connectors.items,
+  };
+}
+
+export function upsertSandboxInstance(
+  config: RawGatewayConfig,
+  instanceId: string,
+  type: string,
+  instanceConfig: Record<string, unknown>,
+): void {
+  const next = ensureGatewayConfigShape(config);
+  next.sandboxes.items[instanceId] = {
+    type,
+    ...structuredClone(instanceConfig),
+  };
+  config.sandboxes = {
+    ...next.sandboxes,
+    items: next.sandboxes.items,
+  };
+}
+
+export function setDefaultProviderIfMissingOrInvalid(config: RawGatewayConfig): void {
+  const next = ensureGatewayConfigShape(config);
+  const items = next.providers.items;
+  const defaultProvider = next.providers.default;
+
+  if (defaultProvider && items[defaultProvider]) {
+    config.providers = next.providers;
+    if (!next.routes.defaults.provider) {
+      config.routes = {
+        ...next.routes,
+        defaults: {
+          ...next.routes.defaults,
+          provider: defaultProvider,
+        },
+      };
+    }
+    return;
+  }
+
+  const candidates = Object.keys(items).sort((a, b) => a.localeCompare(b));
+  if (candidates.length === 0) {
+    config.providers = next.providers;
+    return;
+  }
+
+  config.providers = {
+    ...next.providers,
+    default: candidates[0]!,
+    items,
+  };
+  config.routes = {
+    ...next.routes,
+    defaults: {
+      ...next.routes.defaults,
+      provider: candidates[0]!,
+    },
+  };
+}
+
+export function upsertRoute(config: RawGatewayConfig, routeId: string, profile: RawRouteProfile): void {
+  const next = ensureGatewayConfigShape(config);
+  next.routes.items[routeId] = {
+    projectRoot: profile.projectRoot,
+    ...(profile.tools ? { tools: profile.tools } : {}),
+    ...(profile.mentions ? { mentions: profile.mentions } : {}),
+    ...(profile.provider ? { provider: profile.provider } : {}),
+    ...(profile.sandbox ? { sandbox: profile.sandbox } : {}),
+    ...(typeof profile.systemPromptFile === "string" ? { systemPromptFile: profile.systemPromptFile } : {}),
+  };
+  config.routes = {
+    ...next.routes,
+    items: next.routes.items,
+  };
+}
+
+export function upsertBinding(config: RawGatewayConfig, bindingId: string, binding: RawBindingConfig): void {
+  const next = ensureGatewayConfigShape(config);
+  next.bindings.items[bindingId] = structuredClone(binding);
+  config.bindings = {
+    ...next.bindings,
+    items: next.bindings.items,
+  };
+}
+
+export function listContributionIds(config: RawGatewayConfig): {
+  providers: string[];
+  connectors: string[];
+  sandboxes: string[];
+} {
+  const next = ensureGatewayConfigShape(config);
+
+  return {
+    providers: Object.values(next.providers.items).map((instance) => instance.type),
+    connectors: Object.values(next.connectors.items).map((instance) => instance.type),
+    sandboxes: Object.values(next.sandboxes.items).map((instance) => instance.type),
+  };
+}