@dobby.ai/dobby 0.1.0 → 0.1.2

package/src/core/tests/typing-controller.test.ts

@@ -1,129 +0,0 @@
-import assert from "node:assert/strict";
-import { setTimeout as delay } from "node:timers/promises";
-import test from "node:test";
-import { createTypingKeepAliveController } from "../typing-controller.js";
-import type {
-  ConnectorPlugin,
-  GatewayLogger,
-  InboundEnvelope,
-} from "../types.js";
-
-function createLogger(): GatewayLogger {
-  return {
-    error() {},
-    warn() {},
-    info() {},
-    debug() {},
-  } as unknown as GatewayLogger;
-}
-
-function createInbound(): InboundEnvelope {
-  return {
-    connectorId: "discord.main",
-    platform: "discord",
-    accountId: "discord.main",
-    source: {
-      type: "channel",
-      id: "123",
-    },
-    chatId: "123",
-    messageId: "m-1",
-    userId: "u-1",
-    userName: "tester",
-    text: "hello",
-    attachments: [],
-    timestampMs: Date.now(),
-    raw: {},
-    isDirectMessage: false,
-    mentionedBot: true,
-  };
-}
-
-function createConnector(sentTyping: number[]): ConnectorPlugin {
-  return {
-    id: "discord.main",
-    platform: "discord",
-    name: "discord",
-    capabilities: {
-      updateStrategy: "edit",
-      supportedSources: ["channel"],
-      supportsThread: true,
-      supportsTyping: true,
-      supportsFileUpload: true,
-      maxTextLength: 2000,
-    },
-    async start() {},
-    async send() {
-      return { messageId: "reply-1" };
-    },
-    async sendTyping() {
-      sentTyping.push(Date.now());
-    },
-    async stop() {},
-  };
-}
-
-test("typing is sent before the first visible output when response is slow", async () => {
-  const sentTyping: number[] = [];
-  const controller = createTypingKeepAliveController(
-    createConnector(sentTyping),
-    createInbound(),
-    createLogger(),
-    {
-      initialDelayMs: 0,
-      keepaliveIntervalMs: 200,
-    },
-  );
-
-  try {
-    await controller.prime();
-    assert.equal(sentTyping.length, 1);
-  } finally {
-    controller.stop();
-  }
-});
-
-test("visible output before prime suppresses typing", async () => {
-  const sentTyping: number[] = [];
-  const controller = createTypingKeepAliveController(
-    createConnector(sentTyping),
-    createInbound(),
-    createLogger(),
-    {
-      initialDelayMs: 0,
-      keepaliveIntervalMs: 200,
-    },
-  );
-
-  try {
-    controller.markVisibleOutput();
-    await controller.prime();
-    assert.deepEqual(sentTyping, []);
-  } finally {
-    controller.stop();
-  }
-});
-
-test("visible output stops further typing keepalive", async () => {
-  const sentTyping: number[] = [];
-  const controller = createTypingKeepAliveController(
-    createConnector(sentTyping),
-    createInbound(),
-    createLogger(),
-    {
-      initialDelayMs: 0,
-      keepaliveIntervalMs: 15,
-    },
-  );
-
-  try {
-    await controller.prime();
-    const beforeVisibleOutput = sentTyping.length;
-    assert.equal(beforeVisibleOutput > 0, true);
-    controller.markVisibleOutput();
-    await delay(30);
-    assert.equal(sentTyping.length, beforeVisibleOutput);
-  } finally {
-    controller.stop();
-  }
-});

package/src/core/types.ts

@@ -1,318 +0,0 @@
-import type { ImageContent } from "@mariozechner/pi-ai";
-import type { Logger } from "pino";
-import type { Executor } from "../sandbox/executor.js";
-
-export type Platform = string;
-export type ToolProfile = "full" | "readonly";
-export type MentionPolicy = "required" | "optional";
-export type BindingSourceType = "channel" | "chat";
-export type ExtensionKind = "provider" | "connector" | "sandbox";
-export type ExtensionApiVersion = "1.0";
-export const BUILTIN_HOST_SANDBOX_ID = "host.builtin";
-
-export interface InboundAttachment {
-  id: string;
-  fileName?: string;
-  mimeType?: string;
-  size?: number;
-  localPath?: string;
-  remoteUrl?: string;
-}
-
-export interface BindingSource {
-  type: BindingSourceType;
-  id: string;
-}
-
-export interface InboundEnvelope {
-  connectorId: string;
-  platform: Platform;
-  accountId: string;
-  guildId?: string;
-  source: BindingSource;
-  chatId: string;
-  threadId?: string;
-  messageId: string;
-  userId: string;
-  userName?: string;
-  text: string;
-  attachments: InboundAttachment[];
-  timestampMs: number;
-  raw: unknown;
-  isDirectMessage: boolean;
-  mentionedBot: boolean;
-}
-
-export interface OutboundAttachment {
-  localPath: string;
-  title?: string;
-}
-
-export interface OutboundEnvelope {
-  platform: Platform;
-  accountId: string;
-  chatId: string;
-  threadId?: string;
-  replyToMessageId?: string;
-  mode: "create" | "update";
-  targetMessageId?: string;
-  text: string;
-  attachments?: OutboundAttachment[];
-  metadata?: Record<string, string>;
-}
-
-export interface ConnectorSendResult {
-  messageId?: string;
-}
-
-export interface ConnectorTypingEnvelope {
-  platform: Platform;
-  accountId: string;
-  chatId: string;
-  threadId?: string;
-}
-
-export interface ConnectorContext {
-  emitInbound: (msg: InboundEnvelope) => Promise<void>;
-  emitControl: (event: {
-    type: "stop";
-    connectorId: string;
-    platform: Platform;
-    accountId: string;
-    chatId: string;
-    threadId?: string;
-  }) => Promise<void>;
-}
-
-export type ConnectorUpdateStrategy = "edit" | "final_only" | "append";
-
-export interface ConnectorCapabilities {
-  updateStrategy: ConnectorUpdateStrategy;
-  supportedSources: BindingSourceType[];
-  supportsThread: boolean;
-  supportsTyping: boolean;
-  supportsFileUpload: boolean;
-  maxTextLength?: number;
-}
-
-export interface ConnectorPlugin {
-  readonly id: string;
-  readonly platform: Platform;
-  readonly name: string;
-  readonly capabilities: ConnectorCapabilities;
-  start(ctx: ConnectorContext): Promise<void>;
-  send(message: OutboundEnvelope): Promise<ConnectorSendResult>;
-  sendTyping?(message: ConnectorTypingEnvelope): Promise<void>;
-  stop(): Promise<void>;
-}
-
-export interface RouteDefaultsConfig {
-  provider: string;
-  sandbox: string;
-  tools: ToolProfile;
-  mentions: MentionPolicy;
-}
-
-export interface RouteProfile {
-  projectRoot: string;
-  tools: ToolProfile;
-  mentions: MentionPolicy;
-  provider: string;
-  sandbox: string;
-  systemPromptFile?: string;
-}
-
-export interface RoutesConfig {
-  defaults: RouteDefaultsConfig;
-  items: Record<string, RouteProfile>;
-}
-
-export interface ExtensionPackageConfig {
-  package: string;
-  enabled?: boolean;
-}
-
-export interface ExtensionsConfig {
-  allowList: ExtensionPackageConfig[];
-}
-
-export interface ExtensionInstanceConfig {
-  type: string;
-  config: Record<string, unknown>;
-}
-
-export interface ProvidersConfig {
-  default: string;
-  items: Record<string, ExtensionInstanceConfig>;
-}
-
-export interface ConnectorsConfig {
-  items: Record<string, ExtensionInstanceConfig>;
-}
-
-export interface SandboxesConfig {
-  default?: string;
-  items: Record<string, ExtensionInstanceConfig>;
-}
-
-export interface BindingConfig {
-  connector: string;
-  source: BindingSource;
-  route: string;
-}
-
-export interface BindingsConfig {
-  items: Record<string, BindingConfig>;
-}
-
-export interface DataConfig {
-  rootDir: string;
-  sessionsDir: string;
-  attachmentsDir: string;
-  logsDir: string;
-  stateDir: string;
-  dedupTtlMs: number;
-}
-
-export interface GatewayConfig {
-  extensions: ExtensionsConfig;
-  providers: ProvidersConfig;
-  connectors: ConnectorsConfig;
-  sandboxes: SandboxesConfig;
-  routes: RoutesConfig;
-  bindings: BindingsConfig;
-  data: DataConfig;
-}
-
-export interface RouteResolution {
-  routeId: string;
-  profile: RouteProfile;
-}
-
-export interface BindingResolution {
-  bindingId: string;
-  config: BindingConfig;
-}
-
-export interface PromptPayload {
-  text: string;
-  images: ImageContent[];
-}
-
-export type GatewayAgentEvent =
-  | { type: "message_delta"; delta: string }
-  | { type: "message_complete"; text: string }
-  | { type: "tool_start"; toolName: string }
-  | { type: "tool_end"; toolName: string; isError: boolean; output: string }
-  | { type: "status"; message: string };
-
-export interface GatewayAgentRuntime {
-  prompt(text: string, options?: { images?: ImageContent[] }): Promise<void>;
-  subscribe(listener: (event: GatewayAgentEvent) => void): () => void;
-  abort(): Promise<void>;
-  dispose(): void;
-}
-
-export interface ConversationRuntime {
-  key: string;
-  routeId: string;
-  route: RouteProfile;
-  providerId: string;
-  sandboxId: string;
-  runtime: GatewayAgentRuntime;
-  close: () => Promise<void>;
-}
-
-export interface ExtensionContributionManifest {
-  id: string;
-  kind: ExtensionKind;
-  entry: string;
-  capabilities?: Record<string, unknown>;
-}
-
-export interface ExtensionManifest {
-  apiVersion: ExtensionApiVersion | string;
-  name: string;
-  version: string;
-  contributions: ExtensionContributionManifest[];
-}
-
-export interface ExtensionHostContext {
-  logger: GatewayLogger;
-  configBaseDir: string;
-}
-
-export interface ProviderRuntimeCreateOptions {
-  conversationKey: string;
-  route: RouteResolution;
-  inbound: InboundEnvelope;
-  executor: Executor;
-  sessionPolicy?: "shared-session" | "ephemeral";
-}
-
-export interface ProviderSessionArchiveOptions {
-  conversationKey: string;
-  inbound: InboundEnvelope;
-  sessionPolicy?: "shared-session" | "ephemeral";
-  archivedAtMs?: number;
-}
-
-export interface ProviderSessionArchiveResult {
-  archived: boolean;
-  archivePath?: string;
-}
-
-export interface ProviderInstance {
-  id: string;
-  createRuntime(options: ProviderRuntimeCreateOptions): Promise<GatewayAgentRuntime>;
-  archiveSession?(options: ProviderSessionArchiveOptions): Promise<ProviderSessionArchiveResult>;
-  close?: () => Promise<void>;
-}
-
-export interface ProviderInstanceCreateOptions {
-  instanceId: string;
-  config: Record<string, unknown>;
-  host: ExtensionHostContext;
-  data: DataConfig;
-}
-
-export interface ProviderContributionModule {
-  kind: "provider";
-  configSchema?: Record<string, unknown>;
-  createInstance(options: ProviderInstanceCreateOptions): Promise<ProviderInstance> | ProviderInstance;
-}
-
-export interface ConnectorInstanceCreateOptions {
-  instanceId: string;
-  config: Record<string, unknown>;
-  host: ExtensionHostContext;
-  attachmentsRoot: string;
-}
-
-export interface ConnectorContributionModule {
-  kind: "connector";
-  configSchema?: Record<string, unknown>;
-  createInstance(options: ConnectorInstanceCreateOptions): Promise<ConnectorPlugin> | ConnectorPlugin;
-}
-
-export interface SandboxInstance {
-  id: string;
-  executor: Executor;
-  close?: () => Promise<void>;
-}
-
-export interface SandboxInstanceCreateOptions {
-  instanceId: string;
-  config: Record<string, unknown>;
-  host: ExtensionHostContext;
-}
-
-export interface SandboxContributionModule {
-  kind: "sandbox";
-  configSchema?: Record<string, unknown>;
-  createInstance(options: SandboxInstanceCreateOptions): Promise<SandboxInstance> | SandboxInstance;
-}
-
-export type ExtensionContributionModule = ProviderContributionModule | ConnectorContributionModule | SandboxContributionModule;
-
-export type GatewayLogger = Logger;

package/src/core/typing-controller.ts

@@ -1,119 +0,0 @@
-import type {
-  ConnectorPlugin,
-  GatewayLogger,
-  InboundEnvelope,
-} from "./types.js";
-
-const DEFAULT_TYPING_INITIAL_DELAY_MS = 0;
-const DEFAULT_TYPING_KEEPALIVE_INTERVAL_MS = 8_000;
-
-export interface TypingController {
-  prime: () => Promise<void>;
-  markVisibleOutput: () => void;
-  stop: () => void;
-}
-
-export function createTypingKeepAliveController(
-  connector: ConnectorPlugin,
-  message: InboundEnvelope,
-  logger: GatewayLogger,
-  options: {
-    initialDelayMs?: number;
-    keepaliveIntervalMs?: number;
-  } = {},
-): TypingController {
-  const sendTypingMethod = connector.sendTyping;
-  if (!connector.capabilities.supportsTyping || !sendTypingMethod) {
-    return {
-      prime: async () => {},
-      markVisibleOutput: () => {},
-      stop: () => {},
-    };
-  }
-
-  const typingTarget = {
-    platform: message.platform,
-    accountId: message.accountId,
-    chatId: message.chatId,
-    ...(message.threadId ? { threadId: message.threadId } : {}),
-  };
-  const initialDelayMs = options.initialDelayMs ?? DEFAULT_TYPING_INITIAL_DELAY_MS;
-  const keepaliveIntervalMs = options.keepaliveIntervalMs ?? DEFAULT_TYPING_KEEPALIVE_INTERVAL_MS;
-  let stopped = false;
-  let visibleOutputSent = false;
-  let inFlight = false;
-  let keepaliveTimer: NodeJS.Timeout | null = null;
-
-  const clearKeepalive = (): void => {
-    if (!keepaliveTimer) {
-      return;
-    }
-    clearInterval(keepaliveTimer);
-    keepaliveTimer = null;
-  };
-
-  const sendTyping = async (): Promise<void> => {
-    if (stopped || visibleOutputSent || inFlight) {
-      return;
-    }
-
-    inFlight = true;
-    try {
-      await sendTypingMethod.call(connector, typingTarget);
-    } catch (error) {
-      logger.warn(
-        {
-          err: error,
-          connectorId: message.connectorId,
-          chatId: message.chatId,
-          threadId: message.threadId,
-        },
-        "Failed to send typing indicator",
-      );
-    } finally {
-      inFlight = false;
-    }
-  };
-
-  const startKeepalive = (): void => {
-    if (keepaliveTimer || stopped || visibleOutputSent) {
-      return;
-    }
-
-    keepaliveTimer = setInterval(() => {
-      void sendTyping();
-    }, keepaliveIntervalMs);
-  };
-
-  return {
-    prime: async () => {
-      if (stopped || visibleOutputSent) {
-        return;
-      }
-
-      if (initialDelayMs > 0) {
-        await new Promise<void>((resolve) => {
-          const timer = setTimeout(resolve, initialDelayMs);
-          if (stopped || visibleOutputSent) {
-            clearTimeout(timer);
-            resolve();
-          }
-        });
-      }
-
-      await sendTyping();
-      startKeepalive();
-    },
-    markVisibleOutput: () => {
-      if (visibleOutputSent) {
-        return;
-      }
-      visibleOutputSent = true;
-      clearKeepalive();
-    },
-    stop: () => {
-      stopped = true;
-      clearKeepalive();
-    },
-  };
-}

package/src/cron/config.ts

@@ -1,154 +0,0 @@
-import { dirname, isAbsolute, resolve } from "node:path";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { z } from "zod";
-import type { GatewayConfig } from "../core/types.js";
-import type { CronConfig } from "./types.js";
-
-interface LoadCronConfigOptions {
-  gatewayConfigPath: string;
-  gatewayConfig: GatewayConfig;
-  explicitCronConfigPath?: string;
-}
-
-interface CronConfigResolution {
-  configPath: string;
-  source: "explicit" | "env" | "gateway" | "state";
-}
-
-export interface LoadedCronConfig {
-  configPath: string;
-  source: "explicit" | "env" | "gateway" | "state";
-  config: CronConfig;
-}
-
-const rawCronConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  storeFile: z.string().min(1).optional(),
-  runLogFile: z.string().min(1).optional(),
-  pollIntervalMs: z.number().int().positive().default(10_000),
-  maxConcurrentRuns: z.number().int().positive().default(1),
-  runMissedOnStartup: z.boolean().default(true),
-  jobTimeoutMs: z.number().int().positive().default(10 * 60 * 1000),
-});
-
-type RawCronConfig = z.infer<typeof rawCronConfigSchema>;
-
-function expandHome(value: string): string {
-  if (value === "~") {
-    return homedir();
-  }
-
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return resolve(homedir(), value.slice(2));
-  }
-
-  return value;
-}
-
-function gatewayConfigBaseDir(gatewayConfigPath: string): string {
-  const configDir = dirname(resolve(gatewayConfigPath));
-  return configDir.endsWith("/config") || configDir.endsWith("\\config")
-    ? resolve(configDir, "..")
-    : configDir;
-}
-
-function resolvePathFromBase(baseDir: string, value: string): string {
-  const expanded = expandHome(value);
-  return isAbsolute(expanded) ? resolve(expanded) : resolve(baseDir, expanded);
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function defaultCronConfigPayload(): RawCronConfig {
-  return {
-    enabled: true,
-    storeFile: "./data/state/cron-jobs.json",
-    runLogFile: "./data/state/cron-runs.jsonl",
-    pollIntervalMs: 10_000,
-    maxConcurrentRuns: 1,
-    runMissedOnStartup: true,
-    jobTimeoutMs: 10 * 60 * 1000,
-  };
-}
-
-async function ensureCronConfigFile(configPath: string): Promise<void> {
-  if (await fileExists(configPath)) {
-    return;
-  }
-
-  await mkdir(dirname(configPath), { recursive: true });
-  const payload = `${JSON.stringify(defaultCronConfigPayload(), null, 2)}\n`;
-  await writeFile(configPath, payload, "utf-8");
-}
-
-function resolveCronConfigPath(options: LoadCronConfigOptions): CronConfigResolution {
-  if (options.explicitCronConfigPath && options.explicitCronConfigPath.trim().length > 0) {
-    const rawPath = options.explicitCronConfigPath.trim();
-    const expanded = expandHome(rawPath);
-    const configPath = isAbsolute(expanded) ? resolve(expanded) : resolve(process.cwd(), expanded);
-    return { configPath, source: "explicit" };
-  }
-
-  const envPath = process.env.DOBBY_CRON_CONFIG_PATH?.trim();
-  if (envPath) {
-    const expanded = expandHome(envPath);
-    const configPath = isAbsolute(expanded) ? resolve(expanded) : resolve(process.cwd(), expanded);
-    return { configPath, source: "env" };
-  }
-
-  const candidate = resolve(dirname(resolve(options.gatewayConfigPath)), "cron.json");
-  if (process.env.DOBBY_CRON_CONFIG_PATH === undefined && options.explicitCronConfigPath === undefined) {
-    // no-op branch to make intent explicit for the resolution order
-  }
-
-  return {
-    configPath: candidate,
-    source: "gateway",
-  };
-}
-
-function normalizeCronConfig(gatewayConfigPath: string, gatewayConfig: GatewayConfig, raw: RawCronConfig): CronConfig {
-  const baseDir = gatewayConfigBaseDir(gatewayConfigPath);
-  const defaultStoreFile = resolve(gatewayConfig.data.stateDir, "cron-jobs.json");
-  const defaultRunLogFile = resolve(gatewayConfig.data.stateDir, "cron-runs.jsonl");
-  return {
-    enabled: raw.enabled,
-    storeFile: raw.storeFile ? resolvePathFromBase(baseDir, raw.storeFile) : defaultStoreFile,
-    runLogFile: raw.runLogFile ? resolvePathFromBase(baseDir, raw.runLogFile) : defaultRunLogFile,
-    pollIntervalMs: raw.pollIntervalMs,
-    maxConcurrentRuns: raw.maxConcurrentRuns,
-    runMissedOnStartup: raw.runMissedOnStartup,
-    jobTimeoutMs: raw.jobTimeoutMs,
-  };
-}
-
-export async function loadCronConfig(options: LoadCronConfigOptions): Promise<LoadedCronConfig> {
-  const resolved = resolveCronConfigPath(options);
-  const gatewayFallbackPath = resolve(options.gatewayConfig.data.stateDir, "cron.config.json");
-
-  let configPath = resolved.configPath;
-  let source = resolved.source;
-
-  if (source === "gateway" && !(await fileExists(configPath))) {
-    configPath = gatewayFallbackPath;
-    source = "state";
-  }
-
-  await ensureCronConfigFile(configPath);
-  const raw = await readFile(configPath, "utf-8");
-  const parsed = rawCronConfigSchema.parse(JSON.parse(raw));
-
-  return {
-    configPath,
-    source,
-    config: normalizeCronConfig(options.gatewayConfigPath, options.gatewayConfig, parsed),
-  };
-}