@synergenius/flow-weaver-pack-weaver 0.8.1

package/src/bot/approvals.ts

@@ -0,0 +1,273 @@
+import * as readline from 'node:readline';
+import type { ApprovalMode, NotificationEvent } from './types.js';
+import type { DashboardServer } from './dashboard.js'; // type-only, no circular runtime dep
+
+export interface ApprovalRequest {
+  context: Record<string, unknown>;
+  prompt: string;
+}
+
+export interface ApprovalResult {
+  approved: boolean;
+  reason: string;
+}
+
+export interface ApprovalHandler {
+  handle(
+    request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult>;
+}
+
+export interface ApprovalHandlerOptions {
+  timeoutSeconds: number;
+  webhookUrl?: string;
+  notifier: (event: NotificationEvent) => Promise<void>;
+  webOpen?: boolean;
+  dashboardServer?: DashboardServer;
+}
+
+export function createApprovalHandler(
+  mode: ApprovalMode,
+  options: ApprovalHandlerOptions,
+): ApprovalHandler {
+  switch (mode) {
+    case 'auto':
+      return new AutoApproval(options.notifier);
+    case 'prompt':
+      return new PromptApproval(options.timeoutSeconds, options.notifier);
+    case 'webhook':
+      return new WebhookApproval(
+        options.webhookUrl ?? '',
+        options.timeoutSeconds,
+        options.notifier,
+      );
+    case 'timeout-auto':
+      return new TimeoutAutoApproval(options.timeoutSeconds, options.notifier);
+    case 'web':
+      return new LazyWebApproval(options);
+  }
+}
+
+class AutoApproval implements ApprovalHandler {
+  constructor(private notifier: (event: NotificationEvent) => Promise<void>) {}
+
+  async handle(
+    _request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult> {
+    await this.notifier(event);
+    return { approved: true, reason: 'auto-approved by Weaver' };
+  }
+}
+
+class PromptApproval implements ApprovalHandler {
+  constructor(
+    private timeoutSeconds: number,
+    private notifier: (event: NotificationEvent) => Promise<void>,
+  ) {}
+
+  async handle(
+    request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult> {
+    await this.notifier(event);
+
+    // Non-TTY: fall back to timeout-auto
+    if (!process.stdin.isTTY) {
+      console.log(
+        `[weaver] No TTY available, auto-approving after ${this.timeoutSeconds}s`,
+      );
+      await new Promise((r) => setTimeout(r, this.timeoutSeconds * 1000));
+      return { approved: true, reason: 'auto-approved (no TTY)' };
+    }
+
+    const summary =
+      typeof request.context === 'string'
+        ? request.context
+        : JSON.stringify(request.context, null, 2);
+
+    console.log('\n[weaver] Approval required:');
+    console.log(summary.slice(0, 500));
+    if (summary.length > 500) console.log('  ... (truncated)');
+
+    const answer = await this.askWithTimeout(
+      `\n[weaver] Approve? (y/n, auto-approves in ${this.timeoutSeconds}s): `,
+      this.timeoutSeconds,
+    );
+
+    if (answer === null) {
+      return {
+        approved: true,
+        reason: `auto-approved after ${this.timeoutSeconds}s timeout`,
+      };
+    }
+
+    const approved = answer.trim().toLowerCase().startsWith('y');
+    return {
+      approved,
+      reason: approved ? 'approved by user' : 'rejected by user',
+    };
+  }
+
+  private askWithTimeout(
+    prompt: string,
+    timeoutSeconds: number,
+  ): Promise<string | null> {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const timer = setTimeout(() => {
+        console.log('\n[weaver] Timeout reached, auto-approving');
+        rl.close();
+        resolve(null);
+      }, timeoutSeconds * 1000);
+
+      rl.question(prompt, (answer) => {
+        clearTimeout(timer);
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+}
+
+class WebhookApproval implements ApprovalHandler {
+  constructor(
+    private webhookUrl: string,
+    private timeoutSeconds: number,
+    private notifier: (event: NotificationEvent) => Promise<void>,
+  ) {}
+
+  async handle(
+    request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult> {
+    await this.notifier(event);
+
+    if (!this.webhookUrl) {
+      console.error(
+        '[weaver] Webhook approval requires webhookUrl in approval config, falling back to timeout-auto',
+      );
+      await new Promise((r) => setTimeout(r, this.timeoutSeconds * 1000));
+      return { approved: true, reason: 'auto-approved (no webhookUrl)' };
+    }
+
+    // POST the proposal to the webhook
+    try {
+      const resp = await fetch(this.webhookUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'approval-request',
+          proposal: request.context,
+          prompt: request.prompt,
+          timeoutSeconds: this.timeoutSeconds,
+        }),
+      });
+
+      if (!resp.ok) {
+        console.error(
+          `[weaver] Webhook POST failed: ${resp.status}, falling back to timeout-auto`,
+        );
+        await new Promise((r) => setTimeout(r, this.timeoutSeconds * 1000));
+        return { approved: true, reason: 'auto-approved (webhook error)' };
+      }
+
+      // Poll for response
+      const pollUrl =
+        resp.headers.get('location') ?? this.webhookUrl + '/status';
+      return await this.pollForDecision(pollUrl);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[weaver] Webhook error: ${msg}, falling back to timeout-auto`,
+      );
+      await new Promise((r) => setTimeout(r, this.timeoutSeconds * 1000));
+      return { approved: true, reason: 'auto-approved (webhook error)' };
+    }
+  }
+
+  private async pollForDecision(url: string): Promise<ApprovalResult> {
+    const deadline = Date.now() + this.timeoutSeconds * 1000;
+    const interval = 5000;
+
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, interval));
+
+      try {
+        const resp = await fetch(url);
+        if (!resp.ok) continue;
+
+        const body = (await resp.json()) as {
+          approved?: boolean;
+          reason?: string;
+          pending?: boolean;
+        };
+        if (body.pending) continue;
+
+        return {
+          approved: body.approved ?? true,
+          reason: body.reason ?? (body.approved ? 'approved via webhook' : 'rejected via webhook'),
+        };
+      } catch {
+        continue;
+      }
+    }
+
+    return {
+      approved: true,
+      reason: `auto-approved after ${this.timeoutSeconds}s webhook timeout`,
+    };
+  }
+}
+
+class TimeoutAutoApproval implements ApprovalHandler {
+  constructor(
+    private timeoutSeconds: number,
+    private notifier: (event: NotificationEvent) => Promise<void>,
+  ) {}
+
+  async handle(
+    _request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult> {
+    await this.notifier(event);
+    console.log(
+      `[weaver] Waiting ${this.timeoutSeconds}s before auto-approving...`,
+    );
+    await new Promise((r) => setTimeout(r, this.timeoutSeconds * 1000));
+    return {
+      approved: true,
+      reason: `auto-approved after ${this.timeoutSeconds}s timeout`,
+    };
+  }
+}
+
+class LazyWebApproval implements ApprovalHandler {
+  private inner: ApprovalHandler | null = null;
+  private options: ApprovalHandlerOptions;
+
+  constructor(options: ApprovalHandlerOptions) {
+    this.options = options;
+  }
+
+  async handle(
+    request: ApprovalRequest,
+    event: NotificationEvent,
+  ): Promise<ApprovalResult> {
+    if (!this.inner) {
+      const { WebApprovalHandler } = await import('./web-approval.js');
+      this.inner = new WebApprovalHandler({
+        timeoutSeconds: this.options.timeoutSeconds,
+        open: this.options.webOpen ?? true,
+        notifier: this.options.notifier,
+        dashboardServer: this.options.dashboardServer,
+      });
+    }
+    return this.inner.handle(request, event);
+  }
+}

package/src/bot/audit-logger.ts

@@ -0,0 +1,45 @@
+import type { AuditEventType, AuditEventCallback } from './types.js';
+import { AuditStore } from './audit-store.js';
+
+let store: AuditStore | null = null;
+let currentRunId: string | null = null;
+let onEvent: AuditEventCallback | undefined;
+
+export function initAuditLogger(runId: string, callback?: AuditEventCallback): void {
+  try {
+    store = new AuditStore();
+  } catch {
+    store = null;
+  }
+  currentRunId = runId;
+  onEvent = callback;
+}
+
+export function auditEmit(type: AuditEventType, data?: Record<string, unknown>): void {
+  if (!currentRunId) return;
+
+  const event = {
+    type,
+    timestamp: new Date().toISOString(),
+    runId: currentRunId,
+    data,
+  };
+
+  try {
+    store?.emit(event);
+  } catch {
+    // non-fatal
+  }
+
+  try {
+    onEvent?.(event);
+  } catch {
+    // non-fatal
+  }
+}
+
+export function teardownAuditLogger(): void {
+  store = null;
+  currentRunId = null;
+  onEvent = undefined;
+}

package/src/bot/audit-store.ts

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { AuditEvent } from './types.js';
+
+export class AuditStore {
+  private readonly dir: string;
+  private readonly filePath: string;
+
+  constructor(storeDir?: string) {
+    this.dir = storeDir ?? process.env.WEAVER_HISTORY_DIR ?? path.join(os.homedir(), '.weaver');
+    fs.mkdirSync(this.dir, { recursive: true });
+    this.filePath = path.join(this.dir, 'audit.ndjson');
+  }
+
+  emit(event: AuditEvent): void {
+    fs.appendFileSync(this.filePath, JSON.stringify(event) + '\n', 'utf-8');
+  }
+
+  queryByRun(runId: string): AuditEvent[] {
+    return this.readAll().filter((e) => e.runId === runId);
+  }
+
+  queryRecent(limit = 50): AuditEvent[] {
+    const all = this.readAll();
+    return all.slice(-limit);
+  }
+
+  prune(maxAgeDays: number): number {
+    const all = this.readAll();
+    if (all.length === 0) return 0;
+
+    const cutoff = new Date(Date.now() - maxAgeDays * 86_400_000).toISOString();
+    const kept = all.filter((e) => e.timestamp >= cutoff);
+    const pruned = all.length - kept.length;
+
+    if (pruned === 0) return 0;
+
+    const tmpPath = this.filePath + '.tmp';
+    fs.writeFileSync(tmpPath, kept.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+    fs.renameSync(tmpPath, this.filePath);
+
+    return pruned;
+  }
+
+  clear(): boolean {
+    if (!fs.existsSync(this.filePath)) return false;
+    fs.unlinkSync(this.filePath);
+    return true;
+  }
+
+  private readAll(): AuditEvent[] {
+    if (!fs.existsSync(this.filePath)) return [];
+
+    const content = fs.readFileSync(this.filePath, 'utf-8');
+    const lines = content.split('\n').filter((line) => line.trim().length > 0);
+    const events: AuditEvent[] = [];
+
+    for (const line of lines) {
+      try {
+        events.push(JSON.parse(line) as AuditEvent);
+      } catch {
+        // skip corrupt line
+      }
+    }
+
+    return events;
+  }
+}

package/src/bot/bot-agent-channel.ts

@@ -0,0 +1,99 @@
+import type { BotAgentProvider } from './agent-provider.js';
+import type { ApprovalMode, NotificationEvent, StreamChunk, ToolDefinition, ToolUseResult } from './types.js';
+import { createApprovalHandler } from './approvals.js';
+import type { DashboardServer } from './dashboard.js';
+
+export interface BotChannelContext {
+  projectDir: string;
+  workflowFile?: string;
+  cycle?: number;
+}
+
+export class BotAgentChannel {
+  private provider: BotAgentProvider;
+  private approvalHandler: ReturnType<typeof createApprovalHandler>;
+  private notifier: (event: NotificationEvent) => Promise<void>;
+  private context: BotChannelContext;
+
+  constructor(
+    provider: BotAgentProvider,
+    options: {
+      approvalMode: ApprovalMode;
+      approvalTimeoutSeconds: number;
+      approvalWebhookUrl?: string;
+      approvalWebOpen?: boolean;
+      dashboardServer?: DashboardServer;
+      notifier: (event: NotificationEvent) => Promise<void>;
+      context: BotChannelContext;
+    },
+  ) {
+    this.provider = provider;
+    this.notifier = options.notifier;
+    this.context = options.context;
+    this.approvalHandler = createApprovalHandler(options.approvalMode, {
+      timeoutSeconds: options.approvalTimeoutSeconds,
+      webhookUrl: options.approvalWebhookUrl,
+      notifier: options.notifier,
+      webOpen: options.approvalWebOpen,
+      dashboardServer: options.dashboardServer,
+    });
+  }
+
+  async request(agentRequest: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): Promise<object> {
+    if (agentRequest.agentId.includes('approval')) {
+      return this.handleApproval(agentRequest);
+    }
+    return this.provider.decide(agentRequest);
+  }
+
+  private async handleApproval(request: {
+    context: Record<string, unknown>;
+    prompt: string;
+  }): Promise<object> {
+    const event: NotificationEvent = {
+      type: 'approval-needed',
+      cycle: this.context.cycle,
+      projectDir: this.context.projectDir,
+      workflowFile: this.context.workflowFile,
+      proposal: request.context,
+    };
+
+    return this.approvalHandler.handle(request, event);
+  }
+
+  async requestWithTools(
+    agentRequest: { agentId: string; context: Record<string, unknown>; prompt: string },
+    tools: ToolDefinition[],
+  ): Promise<{ result: Record<string, unknown>; toolCalls?: ToolUseResult[] }> {
+    if (this.provider.decideWithTools) {
+      return this.provider.decideWithTools({ ...agentRequest, tools });
+    }
+    const result = await this.provider.decide(agentRequest);
+    return { result };
+  }
+
+  async *streamRequest(agentRequest: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): AsyncIterable<StreamChunk> {
+    if (this.provider.stream) {
+      yield* this.provider.stream(agentRequest);
+      return;
+    }
+    const result = await this.provider.decide(agentRequest);
+    yield { type: 'text', text: JSON.stringify(result) };
+    yield { type: 'done' };
+  }
+
+  // Compat stubs for AgentChannel interface (used by executor, not by nodes)
+  onPause(): Promise<object> {
+    return new Promise(() => {});
+  }
+  resume(_result: object): void {}
+  fail(_reason: string): void {}
+}

package/src/bot/cli-provider.ts

@@ -0,0 +1,169 @@
+import { execSync, spawn } from 'node:child_process';
+import type { BotAgentProvider, OnUsageCallback, StreamChunk, ToolDefinition, ToolUseResult } from './types.js';
+import { buildSystemPrompt } from './system-prompt.js';
+import { parseStreamLine, extractTextFromChunks } from './cli-stream-parser.js';
+
+// Strip CLAUDECODE from child env so nested claude CLI invocations work.
+const childEnv = { ...process.env };
+delete childEnv.CLAUDECODE;
+
+export class CliAgentProvider implements BotAgentProvider {
+  private cli: 'claude-cli' | 'copilot-cli';
+  private model?: string;
+  onUsage?: OnUsageCallback;
+
+  constructor(cli: 'claude-cli' | 'copilot-cli', model?: string) {
+    this.cli = cli;
+    this.model = model;
+  }
+
+  async decide(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): Promise<Record<string, unknown>> {
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr =
+      typeof request.context === 'string'
+        ? request.context
+        : JSON.stringify(request.context, null, 2);
+
+    const fullPrompt = `${systemPrompt}\n\nContext:\n${contextStr}\n\nInstructions:\n${request.prompt}`;
+
+    if (this.cli === 'claude-cli') {
+      const chunks: StreamChunk[] = [];
+      for await (const chunk of this.streamRaw(fullPrompt)) {
+        chunks.push(chunk);
+      }
+      const raw = extractTextFromChunks(chunks);
+      return this.parseJson(raw);
+    }
+
+    // copilot-cli: no stream-json support, keep execSync
+    const raw = execSync('copilot -p --silent --allow-all-tools', {
+      input: fullPrompt,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 120_000,
+      env: childEnv,
+    }).trim();
+
+    return this.parseJson(raw);
+  }
+
+  async *stream(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): AsyncIterable<StreamChunk> {
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr =
+      typeof request.context === 'string'
+        ? request.context
+        : JSON.stringify(request.context, null, 2);
+
+    const fullPrompt = `${systemPrompt}\n\nContext:\n${contextStr}\n\nInstructions:\n${request.prompt}`;
+
+    if (this.cli === 'claude-cli') {
+      yield* this.streamRaw(fullPrompt);
+    } else {
+      const result = await this.decide(request);
+      yield { type: 'text', text: JSON.stringify(result) };
+      yield { type: 'done' };
+    }
+  }
+
+  async decideWithTools(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+    tools: ToolDefinition[];
+  }): Promise<{ result: Record<string, unknown>; toolCalls?: ToolUseResult[] }> {
+    const result = await this.decide(request);
+    return { result };
+  }
+
+  private async *streamRaw(fullPrompt: string): AsyncGenerator<StreamChunk> {
+    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
+    if (this.model) {
+      args.push('--model', this.model);
+    }
+
+    const child = spawn('claude', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: childEnv,
+    });
+
+    child.stdin.write(fullPrompt);
+    child.stdin.end();
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGTERM');
+    }, 120_000);
+
+    let buffer = '';
+
+    try {
+      for await (const data of child.stdout) {
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop()!;
+
+        for (const line of lines) {
+          const chunk = parseStreamLine(line);
+          if (!chunk) continue;
+
+          if (chunk.type === 'usage' && chunk.usage && this.onUsage) {
+            this.onUsage('stream', this.model ?? 'unknown', chunk.usage);
+          }
+
+          yield chunk;
+        }
+      }
+
+      // Process remaining buffer
+      if (buffer.trim()) {
+        const chunk = parseStreamLine(buffer);
+        if (chunk) {
+          if (chunk.type === 'usage' && chunk.usage && this.onUsage) {
+            this.onUsage('stream', this.model ?? 'unknown', chunk.usage);
+          }
+          yield chunk;
+        }
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    // Wait for process exit
+    await new Promise<void>((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code && code !== 0) {
+          reject(new Error(`claude CLI exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      child.on('error', reject);
+    });
+  }
+
+  private parseJson(text: string): Record<string, unknown> {
+    let cleaned = text.trim();
+    if (cleaned.startsWith('```')) {
+      cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    }
+
+    try {
+      return JSON.parse(cleaned);
+    } catch {
+      const match = cleaned.match(/\{[\s\S]*\}/);
+      if (match) {
+        return JSON.parse(match[0]);
+      }
+      throw new Error(`Failed to parse CLI response as JSON: ${text.slice(0, 200)}`);
+    }
+  }
+}