@dobby.ai/dobby 0.1.0

package/dist/src/cli/program.js

@@ -0,0 +1,386 @@
+import { Command } from "commander";
+import { runConfigEditCommand, runConfigListCommand, runConfigSchemaListCommand, runConfigSchemaShowCommand, runConfigShowCommand, } from "./commands/config.js";
+import { runConfigureCommand } from "./commands/configure.js";
+import { runCronAddCommand, runCronListCommand, runCronPauseCommand, runCronRemoveCommand, runCronResumeCommand, runCronRunCommand, runCronStatusCommand, runCronUpdateCommand, } from "./commands/cron.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { runExtensionInstallCommand, runExtensionListCommand, runExtensionUninstallCommand, } from "./commands/extension.js";
+import { runInitCommand } from "./commands/init.js";
+import { runStartCommand } from "./commands/start.js";
+import { runBindingListCommand, runBindingRemoveCommand, runBindingSetCommand, runBotListCommand, runBotSetCommand, runRouteListCommand, runRouteRemoveCommand, runRouteSetCommand, } from "./commands/topology.js";
+/**
+ * Builds the top-level dobby CLI program and registers all subcommands.
+ */
+export function buildProgram() {
+    const program = new Command();
+    program
+        .name("dobby")
+        .description("Discord-first local agent gateway")
+        .showHelpAfterError()
+        .action(async () => {
+        await runStartCommand();
+    });
+    program
+        .command("start")
+        .description("Start the gateway")
+        .action(async () => {
+        await runStartCommand();
+    });
+    program
+        .command("init")
+        .description("Initialize minimal runnable gateway config")
+        .action(async () => {
+        await runInitCommand();
+    });
+    program
+        .command("configure")
+        .description("Interactive configuration wizard")
+        .option("--section <section>", "Config section (repeatable): provider|connector|route|binding|sandbox|data", (value, previous) => [...previous, value], [])
+        .action(async (opts) => {
+        await runConfigureCommand({
+            sections: opts.section,
+        });
+    });
+    const botCommand = program.command("bot").description("Manage bot connector settings");
+    botCommand
+        .command("list")
+        .description("List configured bot connectors")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        await runBotListCommand({
+            json: Boolean(opts.json),
+        });
+    });
+    botCommand
+        .command("set")
+        .description("Update one bot connector")
+        .argument("<connectorId>", "Connector instance ID")
+        .option("--name <name>", "Discord botName")
+        .option("--token <token>", "Discord botToken")
+        .action(async (connectorId, opts) => {
+        await runBotSetCommand({
+            connectorId,
+            ...(typeof opts.name === "string" ? { name: opts.name } : {}),
+            ...(typeof opts.token === "string" ? { token: opts.token } : {}),
+        });
+    });
+    const bindingCommand = program.command("binding").description("Manage connector source-route bindings");
+    bindingCommand
+        .command("list")
+        .description("List bindings")
+        .option("--connector <id>", "Filter by connector instance ID")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        await runBindingListCommand({
+            ...(typeof opts.connector === "string" ? { connectorId: opts.connector } : {}),
+            json: Boolean(opts.json),
+        });
+    });
+    bindingCommand
+        .command("set")
+        .description("Create or update one binding")
+        .argument("<bindingId>", "Binding ID")
+        .requiredOption("--connector <id>", "Connector instance ID")
+        .requiredOption("--source-type <type>", "Source type: channel|chat")
+        .requiredOption("--source-id <id>", "Source ID")
+        .requiredOption("--route <id>", "Route ID")
+        .action(async (bindingId, opts) => {
+        if (opts.sourceType !== "channel" && opts.sourceType !== "chat") {
+            throw new Error("--source-type must be channel or chat");
+        }
+        await runBindingSetCommand({
+            bindingId,
+            connectorId: opts.connector,
+            sourceType: opts.sourceType,
+            sourceId: opts.sourceId,
+            routeId: opts.route,
+        });
+    });
+    bindingCommand
+        .command("remove")
+        .description("Remove one binding")
+        .argument("<bindingId>", "Binding ID")
+        .action(async (bindingId) => {
+        await runBindingRemoveCommand({
+            bindingId,
+        });
+    });
+    const routeCommand = program.command("route").description("Manage route profiles");
+    routeCommand
+        .command("list")
+        .description("List route profiles")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        await runRouteListCommand({
+            json: Boolean(opts.json),
+        });
+    });
+    routeCommand
+        .command("set")
+        .description("Create or update one route")
+        .argument("<routeId>", "Route ID")
+        .option("--project-root <path>", "Route project root")
+        .option("--tools <profile>", "Route tools profile: full|readonly")
+        .option("--provider <id>", "Provider instance ID")
+        .option("--sandbox <id>", "Sandbox instance ID")
+        .option("--mentions <policy>", "Mention policy: required|optional")
+        .action(async (routeId, opts) => {
+        if (typeof opts.mentions === "string"
+            && opts.mentions !== "required"
+            && opts.mentions !== "optional") {
+            throw new Error("--mentions must be required or optional");
+        }
+        await runRouteSetCommand({
+            routeId,
+            ...(typeof opts.projectRoot === "string" ? { projectRoot: opts.projectRoot } : {}),
+            ...(typeof opts.tools === "string" ? { tools: opts.tools } : {}),
+            ...(typeof opts.provider === "string" ? { providerId: opts.provider } : {}),
+            ...(typeof opts.sandbox === "string" ? { sandboxId: opts.sandbox } : {}),
+            ...(typeof opts.mentions === "string" ? { mentions: opts.mentions } : {}),
+        });
+    });
+    routeCommand
+        .command("remove")
+        .description("Remove one route")
+        .argument("<routeId>", "Route ID")
+        .option("--cascade-bindings", "Remove bindings that reference this route", false)
+        .action(async (routeId, opts) => {
+        await runRouteRemoveCommand({
+            routeId,
+            cascadeBindings: Boolean(opts.cascadeBindings),
+        });
+    });
+    const configCommand = program.command("config").description("Inspect and edit config");
+    configCommand
+        .command("show")
+        .description("Show full config or one section")
+        .argument("[section]", "Section: providers|connectors|routes|bindings|sandboxes|data|extensions")
+        .option("--json", "Output JSON", false)
+        .action(async (section, opts) => {
+        await runConfigShowCommand({
+            ...(typeof section === "string" ? { section } : {}),
+            json: Boolean(opts.json),
+        });
+    });
+    configCommand
+        .command("list")
+        .description("List config keys with type and preview")
+        .argument("[section]", "Section: providers|connectors|routes|bindings|sandboxes|data|extensions")
+        .option("--json", "Output JSON", false)
+        .action(async (section, opts) => {
+        await runConfigListCommand({
+            ...(typeof section === "string" ? { section } : {}),
+            json: Boolean(opts.json),
+        });
+    });
+    configCommand
+        .command("edit")
+        .description("Interactive edit for high-frequency sections")
+        .option("--section <section>", "Edit section (repeatable): provider|connector|route|binding", (value, previous) => [...previous, value], [])
+        .action(async (opts) => {
+        await runConfigEditCommand({
+            sections: opts.section,
+        });
+    });
+    const configSchemaCommand = configCommand.command("schema").description("Inspect extension config schemas");
+    configSchemaCommand
+        .command("list")
+        .description("List loaded contributions and schema availability")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        await runConfigSchemaListCommand({
+            json: Boolean(opts.json),
+        });
+    });
+    configSchemaCommand
+        .command("show")
+        .description("Show one contribution config schema")
+        .argument("<contributionId>", "Contribution ID")
+        .option("--json", "Output JSON", false)
+        .action(async (contributionId, opts) => {
+        await runConfigSchemaShowCommand({
+            contributionId,
+            json: Boolean(opts.json),
+        });
+    });
+    const extensionCommand = program.command("extension").description("Manage extensions");
+    extensionCommand
+        .command("install")
+        .description("Install extension package")
+        .argument("<packageSpec>", "npm package spec")
+        .option("--enable", "Enable extension in config after install", false)
+        .option("--json", "Output JSON", false)
+        .action(async (packageSpec, opts) => {
+        await runExtensionInstallCommand({
+            spec: packageSpec,
+            enable: Boolean(opts.enable),
+            json: Boolean(opts.json),
+        });
+    });
+    extensionCommand
+        .command("uninstall")
+        .description("Uninstall extension package")
+        .argument("<packageName>", "Package name")
+        .action(async (packageName) => {
+        await runExtensionUninstallCommand({
+            packageName,
+        });
+    });
+    extensionCommand
+        .command("list")
+        .description("List installed extension packages")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        await runExtensionListCommand({
+            json: Boolean(opts.json),
+        });
+    });
+    program
+        .command("doctor")
+        .description("Validate configuration and common runtime risks")
+        .option("--fix", "Apply conservative fixes", false)
+        .action(async (opts) => {
+        await runDoctorCommand({
+            fix: Boolean(opts.fix),
+        });
+    });
+    const cronCommand = program.command("cron").description("Manage scheduled cron jobs");
+    cronCommand
+        .command("add")
+        .description("Create one cron job")
+        .argument("<name>", "Job name")
+        .requiredOption("--prompt <text>", "Prompt text for each run")
+        .requiredOption("--connector <id>", "Connector instance ID")
+        .requiredOption("--route <id>", "Route ID")
+        .requiredOption("--channel <id>", "Delivery channel/chat ID")
+        .option("--thread <id>", "Delivery thread ID")
+        .option("--session-policy <policy>", "Session policy: stateless|shared-session", "stateless")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every-ms <ms>", "Run at fixed interval in milliseconds")
+        .option("--cron <expr>", "Cron expression")
+        .option("--tz <tz>", "Timezone for cron expression")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (name, opts) => {
+        const parsedEveryMs = typeof opts.everyMs === "string" ? Number(opts.everyMs) : null;
+        await runCronAddCommand({
+            name,
+            prompt: opts.prompt,
+            connectorId: opts.connector,
+            routeId: opts.route,
+            channelId: opts.channel,
+            ...(typeof opts.thread === "string" ? { threadId: opts.thread } : {}),
+            sessionPolicy: opts.sessionPolicy,
+            ...(typeof opts.at === "string" ? { at: opts.at } : {}),
+            ...(parsedEveryMs !== null && Number.isFinite(parsedEveryMs) ? { everyMs: parsedEveryMs } : {}),
+            ...(typeof opts.cron === "string" ? { cronExpr: opts.cron } : {}),
+            ...(typeof opts.tz === "string" ? { tz: opts.tz } : {}),
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("list")
+        .description("List cron jobs")
+        .option("--json", "Output JSON", false)
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (opts) => {
+        await runCronListCommand({
+            json: Boolean(opts.json),
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("status")
+        .description("Show status for all jobs or one job")
+        .argument("[jobId]", "Cron job ID")
+        .option("--json", "Output JSON", false)
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        await runCronStatusCommand({
+            ...(typeof jobId === "string" ? { jobId } : {}),
+            json: Boolean(opts.json),
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("run")
+        .description("Queue one cron job for immediate execution")
+        .argument("<jobId>", "Cron job ID")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        await runCronRunCommand({
+            jobId,
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("update")
+        .description("Update one cron job")
+        .argument("<jobId>", "Cron job ID")
+        .option("--name <name>", "Job name")
+        .option("--prompt <text>", "Job prompt")
+        .option("--connector <id>", "Connector instance ID")
+        .option("--route <id>", "Route ID")
+        .option("--channel <id>", "Delivery channel/chat ID")
+        .option("--thread <id>", "Delivery thread ID")
+        .option("--clear-thread", "Unset delivery thread", false)
+        .option("--session-policy <policy>", "Session policy: stateless|shared-session")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every-ms <ms>", "Run at fixed interval in milliseconds")
+        .option("--cron <expr>", "Cron expression")
+        .option("--tz <tz>", "Timezone for cron expression")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        const parsedEveryMs = typeof opts.everyMs === "string" ? Number(opts.everyMs) : null;
+        await runCronUpdateCommand({
+            jobId,
+            ...(typeof opts.name === "string" ? { name: opts.name } : {}),
+            ...(typeof opts.prompt === "string" ? { prompt: opts.prompt } : {}),
+            ...(typeof opts.connector === "string" ? { connectorId: opts.connector } : {}),
+            ...(typeof opts.route === "string" ? { routeId: opts.route } : {}),
+            ...(typeof opts.channel === "string" ? { channelId: opts.channel } : {}),
+            ...(typeof opts.thread === "string" ? { threadId: opts.thread } : {}),
+            clearThread: Boolean(opts.clearThread),
+            ...(typeof opts.sessionPolicy === "string"
+                ? { sessionPolicy: opts.sessionPolicy }
+                : {}),
+            ...(typeof opts.at === "string" ? { at: opts.at } : {}),
+            ...(parsedEveryMs !== null && Number.isFinite(parsedEveryMs) ? { everyMs: parsedEveryMs } : {}),
+            ...(typeof opts.cron === "string" ? { cronExpr: opts.cron } : {}),
+            ...(typeof opts.tz === "string" ? { tz: opts.tz } : {}),
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("remove")
+        .description("Remove one cron job")
+        .argument("<jobId>", "Cron job ID")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        await runCronRemoveCommand({
+            jobId,
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("pause")
+        .description("Pause one cron job")
+        .argument("<jobId>", "Cron job ID")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        await runCronPauseCommand({
+            jobId,
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    cronCommand
+        .command("resume")
+        .description("Resume one cron job")
+        .argument("<jobId>", "Cron job ID")
+        .option("--cron-config <path>", "Override cron config path")
+        .action(async (jobId, opts) => {
+        await runCronResumeCommand({
+            jobId,
+            ...(typeof opts.cronConfig === "string" ? { cronConfigPath: opts.cronConfig } : {}),
+        });
+    });
+    return program;
+}

package/dist/src/cli/shared/config-io.js

@@ -0,0 +1,223 @@
+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";
+/**
+ * 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) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return value;
+}
+/**
+ * Returns true when a directory looks like the dobby repository root.
+ */
+function isDobbyRepoRoot(candidateDir) {
+    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);
+        return parsed.name === "dobby";
+    }
+    catch {
+        return false;
+    }
+}
+function resolveConfigBaseDir(configPath) {
+    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) {
+    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) {
+    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) {
+    return resolveConfigPathInfo(input).path;
+}
+/**
+ * Formats a user-facing init command hint for missing-config errors.
+ */
+function initCommandHint() {
+    return "dobby init";
+}
+/**
+ * Resolves data.rootDir into an absolute path using config-file-relative semantics.
+ */
+export function resolveDataRootDir(configPath, rawConfig) {
+    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) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reads and parses the raw JSON config file.
+ */
+export async function readRawConfig(configPath) {
+    const absolutePath = resolve(configPath);
+    if (!(await fileExists(absolutePath))) {
+        return null;
+    }
+    const raw = await readFile(absolutePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Config at '${absolutePath}' must be a JSON object`);
+    }
+    return parsed;
+}
+/**
+ * Writes config content atomically via temp file + rename.
+ */
+async function writeAtomic(configPath, content) {
+    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, rawConfig) {
+    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) {
+    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, rawConfig, options) {
+    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) {
+    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;
+}