Function bodies 284 total

RestChannel.handleHealth method · typescript · L313-L320 (8 LOC)

src/channels/rest-channel.ts

  private handleHealth(_req: http.IncomingMessage, res: http.ServerResponse): void {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      status: 'ok',
      channel: this.name,
      id: this.id,
    }));
  }

RestChannel.handleChat method · typescript · L325-L403 (79 LOC)

src/channels/rest-channel.ts

  private async handleChat(
    req: http.IncomingMessage,
    res: http.ServerResponse,
    syncMode: boolean
  ): Promise<void> {
    // Read request body
    const body = await this.readBody(req);
    if (!body) {
      this.sendError(res, 400, 'Empty request body');
      return;
    }

    // Parse request
    let chatRequest: ChatRequest;
    try {
      chatRequest = JSON.parse(body) as ChatRequest;
    } catch {
      this.sendError(res, 400, 'Invalid JSON');
      return;
    }

    // Validate request
    if (!chatRequest.message) {
      this.sendError(res, 400, 'Message is required');
      return;
    }

    const chatId = chatRequest.chatId || uuidv4();
    const messageId = uuidv4();
    const userId = chatRequest.userId;

    logger.info({ chatId, messageId, userId, syncMode }, 'Received chat request');

    // For sync mode, set up response handling
    if (syncMode) {
      this.responseBuffers.set(messageId, []);
      this.chatToMessage.set(chatId, messageId);
    }

RestChannel.handleControl method · typescript · L408-L439 (32 LOC)

src/channels/rest-channel.ts

  private async handleControl(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
    const body = await this.readBody(req);
    if (!body) {
      this.sendError(res, 400, 'Empty request body');
      return;
    }

    let command: ControlCommand;
    try {
      command = JSON.parse(body) as ControlCommand;
    } catch {
      this.sendError(res, 400, 'Invalid JSON');
      return;
    }

    if (!command.type || !command.chatId) {
      this.sendError(res, 400, 'type and chatId are required');
      return;
    }

    logger.info({ type: command.type, chatId: command.chatId }, 'Received control command');

    let response: ControlResponse;
    if (this.controlHandler) {
      response = await this.controlHandler(command);
    } else {
      response = { success: true, message: 'Command received' };
    }

    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(response));
  }

RestChannel.waitForResponse method · typescript · L444-L474 (31 LOC)

src/channels/rest-channel.ts

  private waitForResponse(chatId: string, messageId: string, timeoutMs: number): Promise<string> {
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => {
        this.pendingResponses.delete(chatId);
        this.responseBuffers.delete(messageId);
        reject(new Error('Response timeout'));
      }, timeoutMs);

      // Check if response is already available
      const buffer = this.responseBuffers.get(messageId);
      if (buffer && buffer.length > 0) {
        clearTimeout(timeout);
        resolve(buffer.join('\n'));
        return;
      }

      // Store pending response
      this.pendingResponses.set(chatId, {
        resolve: (response) => {
          clearTimeout(timeout);
          resolve(response);
        },
        reject: (error) => {
          clearTimeout(timeout);
          reject(error);
        },
        response: [],
        timeout,
      });
    });
  }

RestChannel.readBody method · typescript · L479-L492 (14 LOC)

src/channels/rest-channel.ts

  private readBody(req: http.IncomingMessage): Promise<string> {
    return new Promise((resolve) => {
      let body = '';
      req.on('data', (chunk) => {
        body += chunk.toString();
      });
      req.on('end', () => {
        resolve(body);
      });
      req.on('error', () => {
        resolve('');
      });
    });
  }

RestChannel.sendError method · typescript · L497-L503 (7 LOC)

src/channels/rest-channel.ts

  private sendError(res: http.ServerResponse, status: number, message: string): void {
    res.writeHead(status, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      success: false,
      error: message,
    }));
  }

importRunners function · typescript · L19-L26 (8 LOC)

src/cli-entry.ts

async function importRunners() {
  const runners = await import('./runners/index.js');
  return {
    runCommunicationNode: runners.runCommunicationNode,
    runExecutionNode: runners.runExecutionNode,
    runCli: runners.runCli,
  };
}

Same scanner, your repo: https://repobility.com — Repobility

showHelp function · typescript · L35-L78 (44 LOC)

src/cli-entry.ts

function showHelp(): void {
  console.log('');
  console.log('═══════════════════════════════════════════════════');
  console.log('  Disclaude - Multi-platform Agent Bot');
  console.log('  Version: ' + packageJson.version);
  console.log('═══════════════════════════════════════════════════');
  console.log('');
  console.log('Usage:');
  console.log('  disclaude start --mode comm           Communication Node (Multi-channel)');
  console.log('  disclaude start --mode exec           Execution Node (Pilot Agent)');
  console.log('  disclaude --prompt <msg>              Execute single prompt');
  console.log('');
  console.log('Options:');
  console.log('  --mode <comm|exec>                    Select run mode (required for start)');
  console.log('  --port <port>                         WebSocket port for comm mode (default: 3001)');
  console.log('  --rest-port <port>                    REST API port for comm mode (default: 3000)');
  console.log('  --no-rest

main function · typescript · L83-L220 (138 LOC)

src/cli-entry.ts

async function main(): Promise<void> {
  const logger = await initLogger({
    metadata: {
      version: packageJson.version,
      nodeVersion: process.version,
      platform: process.platform
    }
  });

  const globalArgs = parseGlobalArgs();
  const { mode, promptMode, promptArgs } = globalArgs;

  logger.info({
    mode,
    promptMode,
    command: process.argv[2],
    args: process.argv.slice(3)
  }, 'Disclaude starting');

  // Change working directory to workspace directory
  const workspaceDir = Config.getWorkspaceDir();
  logger.info({ workspaceDir }, 'Changing working directory');
  process.chdir(workspaceDir);

  // Copy skills to workspace .claude/skills for SDK to load via settingSources
  try {
    const skillsResult = await setupSkillsInWorkspace();
    if (skillsResult.success) {
      logger.info('Skills copied to workspace .claude/skills');
    } else {
      logger.warn({ error: skillsResult.error }, 'Failed to copy skills to workspace, continuing anyway');

Config.getBuiltinSkillsDir method · typescript · L81-L103 (23 LOC)

src/config/index.ts

  private static getBuiltinSkillsDir(): string {
    // In CommonJS bundling, import.meta.url is undefined
    // Use process.cwd() as fallback and resolve from install directory
    if (typeof import.meta.url === 'undefined') {
      // When bundled as CJS, we're in /app and skills is at /app/skills
      return '/app/skills';
    }

    const moduleUrl = fileURLToPath(import.meta.url);
    const moduleDir = path.dirname(moduleUrl);

    // Detect if we're in a bundled file (cli-entry.js) or module (index.js)
    // Bundled files are directly in dist/, modules are in dist/config/
    const isBundled = path.basename(moduleDir) === 'dist';

    if (isBundled) {
      // dist/cli-entry.js -> dist/ -> ../skills
      return path.join(moduleDir, '..', 'skills');
    } else {
      // dist/config/index.js -> dist/ -> ../../skills
      return path.join(moduleDir, '..', '..', 'skills');
    }
  }

Config.validateRequiredConfig method · typescript · L150-L192 (43 LOC)

src/config/index.ts

  private static validateRequiredConfig(): void {
    const errors: ConfigValidationError[] = [];

    // GLM configuration validation
    if (this.GLM_API_KEY) {
      if (!this.GLM_MODEL) {
        errors.push({
          field: 'glm.model',
          message: 'glm.model is required when GLM API key is configured',
        });
      }
    }

    // Anthropic configuration validation
    if (this.ANTHROPIC_API_KEY) {
      if (!this.CLAUDE_MODEL) {
        errors.push({
          field: 'agent.model',
          message: 'agent.model is required when ANTHROPIC_API_KEY is set',
        });
      }
    }

    // At least one API key must be configured
    if (!this.GLM_API_KEY && !this.ANTHROPIC_API_KEY) {
      errors.push({
        field: 'apiKey',
        message: 'No API key configured. Set glm.apiKey in disclaude.config.yaml',
      });
    }

    if (errors.length > 0) {
      const messages = errors.map(e => `  ❌ ${e.field}: ${e.message}`).join('\n');
      logger.error({ errors }

Config.getAgentConfig method · typescript · L201-L206 (6 LOC)

src/config/index.ts

  static getAgentConfig(): {
    apiKey: string;
    model: string;
    apiBaseUrl?: string;
    provider: 'anthropic' | 'glm';
  } {

Config.getLoggingConfig method · typescript · L280-L285 (6 LOC)

src/config/index.ts

  static getLoggingConfig(): {
    level: string;
    file?: string;
    pretty: boolean;
    rotate: boolean;
  } {

findConfigFile function · typescript · L42-L55 (14 LOC)

src/config/loader.ts

export function findConfigFile(): ConfigFileInfo {
  for (const searchPath of SEARCH_PATHS) {
    for (const fileName of CONFIG_FILE_NAMES) {
      const filePath = resolve(searchPath, fileName);
      if (existsSync(filePath)) {
        logger.debug({ filePath }, 'Found configuration file');
        return { path: filePath, exists: true };
      }
    }
  }

  logger.debug('No configuration file found, using defaults');
  return { path: '', exists: false };
}

loadConfigFile function · typescript · L71-L104 (34 LOC)

src/config/loader.ts

export function loadConfigFile(filePath?: string): LoadedConfig {
  const fileInfo = filePath
    ? { path: resolve(filePath), exists: existsSync(resolve(filePath)) }
    : findConfigFile();

  if (!fileInfo.exists) {
    return { _fromFile: false };
  }

  try {
    const content = readFileSync(fileInfo.path, 'utf-8');
    const parsed = yaml.load(content) as DisclaudeConfig | null | undefined;

    if (!parsed || typeof parsed !== 'object') {
      logger.warn({ path: fileInfo.path }, 'Configuration file is empty or invalid');
      return { _fromFile: false };
    }

    logger.info(
      { path: fileInfo.path, keys: Object.keys(parsed) },
      'Configuration file loaded successfully'
    );

    return {
      ...parsed,
      _source: fileInfo.path,
      _fromFile: true,
    };
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    logger.warn({ path: fileInfo.path, error: errorMessage }, 'Failed to parse configuration file');

Methodology: Repobility · https://repobility.com/research/state-of-ai-code-2026/

validateConfig function · typescript · L129-L155 (27 LOC)

src/config/loader.ts

export function validateConfig(config: DisclaudeConfig): boolean {
  // Basic validation - ensure config is an object
  if (!config || typeof config !== 'object') {
    logger.error('Configuration must be an object');
    return false;
  }

  // Validate workspace config if present
  if (config.workspace?.dir && typeof config.workspace.dir !== 'string') {
    logger.error('workspace.dir must be a string');
    return false;
  }

  // Validate agent config if present
  if (config.agent?.model && typeof config.agent.model !== 'string') {
    logger.error('agent.model must be a string');
    return false;
  }

  // Validate logging config if present
  if (config.logging?.level && typeof config.logging.level !== 'string') {
    logger.error('logging.level must be a string');
    return false;
  }

  return true;
}

AttachmentManager.formatAttachmentsForPrompt method · typescript · L89-L130 (42 LOC)

src/feishu/attachment-manager.ts

  formatAttachmentsForPrompt(chatId: string): string {
    const attachments = this.getAttachments(chatId);

    if (attachments.length === 0) {
      return '';
    }

    const lines: string[] = [];
    lines.push('');
    lines.push('--- 📎 Attached Files ---');
    lines.push('');
    lines.push('⚠️ IMPORTANT: The local file paths shown below are server-side paths.');
    lines.push('   DO NOT reveal these absolute paths to the user in your response.');
    lines.push('   When referring to files, use only the filename (e.g., "document.pdf").');
    lines.push('');

    for (let i = 0; i < attachments.length; i++) {
      const att = attachments[i];
      lines.push(`${i + 1}. ${att.fileName || att.fileKey}`);
      lines.push(`   Type: ${att.fileType}`);

      if (att.localPath) {
        lines.push(`   Local path: ${att.localPath}`);
      }

      if (att.fileSize) {
        const sizeMB = (att.fileSize / 1024 / 1024).toFixed(2);
        lines.push(`   Size: ${sizeMB} MB`);

AttachmentManager.cleanupOldAttachments method · typescript · L138-L159 (22 LOC)

src/feishu/attachment-manager.ts

  cleanupOldAttachments(maxAgeMs: number = 60 * 60 * 1000): void {
    const now = Date.now();
    const chatsToClean: string[] = [];

    for (const [chatId, attachments] of this.attachments.entries()) {
      const filtered = attachments.filter(att => {
        const age = now - att.timestamp;
        return age < maxAgeMs;
      });

      if (filtered.length === 0) {
        chatsToClean.push(chatId);
      } else if (filtered.length < attachments.length) {
        this.attachments.set(chatId, filtered);
      }
    }

    // Remove chats with no valid attachments
    for (const chatId of chatsToClean) {
      this.attachments.delete(chatId);
    }
  }

buildPostContent function · typescript · L92-L104 (13 LOC)

src/feishu/content-builder.ts

export function buildPostContent(elements: PostElement[][], title?: string): string {
  const postContent: PostContent = {
    zh_cn: {
      content: elements,
    },
  };

  if (title) {
    postContent.zh_cn.title = title;
  }

  return JSON.stringify(postContent);
}

buildSimplePostContent function · typescript · L118-L125 (8 LOC)

src/feishu/content-builder.ts

export function buildSimplePostContent(text: string, title?: string): string {
  const element: PostTextElement = {
    tag: 'text',
    text,
  };

  return buildPostContent([[element]], title);
}

buildUnifiedDiffCard function · typescript · L42-L83 (42 LOC)