@synergenius/flow-weaver-pack-weaver 0.8.1

package/src/bot/run-store.ts

@@ -0,0 +1,169 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import * as os from 'node:os';
+import type { RunRecord, RunFilter, RetentionPolicy } from './types.js';
+
+export class RunStore {
+  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, 'history.ndjson');
+  }
+
+  static newId(): string {
+    return crypto.randomUUID();
+  }
+
+  append(record: RunRecord): void {
+    fs.appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
+  }
+
+  list(filter?: RunFilter): RunRecord[] {
+    const all = this.readAll();
+    let filtered = all;
+
+    if (filter?.workflowFile) {
+      const wf = filter.workflowFile;
+      filtered = filtered.filter((r) => r.workflowFile === wf);
+    }
+    if (filter?.outcome) {
+      const out = filter.outcome;
+      filtered = filtered.filter((r) => r.outcome === out);
+    }
+    if (filter?.success !== undefined) {
+      const s = filter.success;
+      filtered = filtered.filter((r) => r.success === s);
+    }
+    if (filter?.since) {
+      const since = filter.since;
+      filtered = filtered.filter((r) => r.startedAt >= since);
+    }
+    if (filter?.before) {
+      const before = filter.before;
+      filtered = filtered.filter((r) => r.startedAt <= before);
+    }
+
+    filtered.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+
+    const limit = filter?.limit ?? 50;
+    return filtered.slice(0, limit);
+  }
+
+  get(idOrPrefix: string): RunRecord | null {
+    if (idOrPrefix.length < 4) {
+      throw new Error('ID prefix must be at least 4 characters');
+    }
+
+    const all = this.readAll();
+    const matches = all.filter((r) => r.id.startsWith(idOrPrefix));
+
+    if (matches.length === 0) return null;
+    if (matches.length === 1) return matches[0]!;
+
+    throw new Error(
+      `Ambiguous ID prefix "${idOrPrefix}" matches ${matches.length} runs: ` +
+        matches.map((r) => r.id).join(', '),
+    );
+  }
+
+  /** Mark a run as in-progress. Creates a small marker file that survives crashes. */
+  markRunning(runId: string, workflowFile: string): void {
+    const marker = path.join(this.dir, `running-${runId}.json`);
+    fs.writeFileSync(marker, JSON.stringify({ id: runId, workflowFile, startedAt: new Date().toISOString(), pid: process.pid }), 'utf-8');
+  }
+
+  /** Remove the in-progress marker after the run completes. */
+  clearRunning(runId: string): void {
+    const marker = path.join(this.dir, `running-${runId}.json`);
+    try { fs.unlinkSync(marker); } catch { /* already gone */ }
+  }
+
+  /** Check for orphaned in-progress markers (runs killed mid-execution). */
+  checkOrphans(): Array<{ id: string; workflowFile: string; startedAt: string; pid: number }> {
+    const orphans: Array<{ id: string; workflowFile: string; startedAt: string; pid: number }> = [];
+    try {
+      const files = fs.readdirSync(this.dir).filter((f) => f.startsWith('running-') && f.endsWith('.json'));
+      for (const file of files) {
+        try {
+          const data = JSON.parse(fs.readFileSync(path.join(this.dir, file), 'utf-8'));
+          // Check if the PID is still alive
+          let alive = false;
+          try { process.kill(data.pid, 0); alive = true; } catch { /* process gone */ }
+          if (!alive) {
+            orphans.push(data);
+            // Record the orphaned run as an error and clean up
+            this.append({
+              id: data.id,
+              workflowFile: data.workflowFile,
+              startedAt: data.startedAt,
+              finishedAt: new Date().toISOString(),
+              durationMs: Date.now() - new Date(data.startedAt).getTime(),
+              success: false,
+              outcome: 'error',
+              summary: 'Process killed during execution (recovered on next start)',
+              dryRun: false,
+            });
+            fs.unlinkSync(path.join(this.dir, file));
+          }
+        } catch { /* skip corrupt marker */ }
+      }
+    } catch { /* dir read failed */ }
+    return orphans;
+  }
+
+  prune(policy: RetentionPolicy): number {
+    const all = this.readAll();
+    if (all.length === 0) return 0;
+
+    all.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    let kept = [...all];
+
+    if (policy.maxAgeDays !== undefined) {
+      const cutoff = new Date(Date.now() - policy.maxAgeDays * 86_400_000).toISOString();
+      kept = kept.filter((r) => r.startedAt >= cutoff);
+    }
+
+    if (policy.maxRecords !== undefined) {
+      kept = kept.slice(0, policy.maxRecords);
+    }
+
+    const pruned = all.length - kept.length;
+    if (pruned === 0) return 0;
+
+    // Rewrite atomically: oldest first in file
+    kept.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    const tmpPath = this.filePath + '.tmp';
+    fs.writeFileSync(tmpPath, kept.map((r) => JSON.stringify(r)).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(): RunRecord[] {
+    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 records: RunRecord[] = [];
+
+    for (const line of lines) {
+      try {
+        records.push(JSON.parse(line) as RunRecord);
+      } catch {
+        console.error('[weaver] Skipping corrupt history line');
+      }
+    }
+
+    return records;
+  }
+}

package/src/bot/runner.ts

@@ -0,0 +1,311 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type {
+  ApprovalMode,
+  AuditEventCallback,
+  BotConfig,
+  BotNotifyConfig,
+  ExecutionEvent,
+  RunOutcome,
+  WeaverConfig,
+  WorkflowResult,
+} from './types.js';
+import { initAuditLogger, auditEmit, teardownAuditLogger } from './audit-logger.js';
+import {
+  createProvider,
+  resolveProviderConfig,
+} from './agent-provider.js';
+import { BotAgentChannel } from './bot-agent-channel.js';
+import {
+  WebhookNotificationChannel,
+  createNotifier,
+} from './notifications.js';
+import type { NotificationErrorHandler } from './notifications.js';
+import { RunStore } from './run-store.js';
+import { CostTracker } from './cost-tracker.js';
+import { CostStore } from './cost-store.js';
+
+function resolveApproval(
+  approval: BotConfig['approval'],
+): { mode: ApprovalMode; timeoutSeconds: number; webhookUrl?: string; webOpen?: boolean } {
+  if (!approval || approval === 'auto') {
+    return { mode: 'auto', timeoutSeconds: 300 };
+  }
+  if (typeof approval === 'string') {
+    return { mode: approval, timeoutSeconds: 300 };
+  }
+  return {
+    mode: approval.mode,
+    timeoutSeconds: approval.timeoutSeconds ?? 300,
+    webhookUrl: approval.webhookUrl,
+    webOpen: approval.webOpen,
+  };
+}
+
+function resolveNotify(
+  notify: BotConfig['notify'],
+): BotNotifyConfig[] {
+  if (!notify) return [];
+  return Array.isArray(notify) ? notify : [notify];
+}
+
+function resolveWeaverConfig(
+  filePath: string,
+  explicit?: WeaverConfig,
+): WeaverConfig {
+  if (explicit) return explicit;
+
+  const dir = path.dirname(filePath);
+  const localConfig = path.join(dir, '.weaver.json');
+  if (fs.existsSync(localConfig)) {
+    return JSON.parse(fs.readFileSync(localConfig, 'utf-8'));
+  }
+
+  const cwdConfig = path.join(process.cwd(), '.weaver.json');
+  if (fs.existsSync(cwdConfig)) {
+    return JSON.parse(fs.readFileSync(cwdConfig, 'utf-8'));
+  }
+
+  return { provider: 'auto' };
+}
+
+function buildSummary(result: unknown): string {
+  if (!result || typeof result !== 'object') return String(result);
+
+  const r = result as Record<string, unknown>;
+  if (typeof r.summary === 'string') return r.summary;
+
+  // Build a meaningful summary from whatever the workflow returned
+  const parts: string[] = [];
+  for (const [key, value] of Object.entries(r)) {
+    if (key === 'onSuccess' || key === 'onFailure') continue;
+    if (value === null || value === undefined) continue;
+    const str = typeof value === 'string' ? value : JSON.stringify(value);
+    parts.push(`${key}: ${str.length > 100 ? str.slice(0, 100) + '...' : str}`);
+  }
+  return parts.length > 0 ? parts.join(', ') : 'completed';
+}
+
+export async function runWorkflow(
+  filePath: string,
+  options?: {
+    params?: Record<string, unknown>;
+    verbose?: boolean;
+    dryRun?: boolean;
+    config?: WeaverConfig;
+    onEvent?: (event: ExecutionEvent) => void;
+    onAuditEvent?: AuditEventCallback;
+    onNotificationError?: NotificationErrorHandler;
+    dashboardServer?: import('./dashboard.js').DashboardServer;
+  },
+): Promise<WorkflowResult> {
+  const absPath = path.resolve(filePath);
+  const verbose = options?.verbose ?? false;
+
+  let store: RunStore | null = null;
+  try { store = new RunStore(); } catch { /* non-fatal */ }
+  const runId = RunStore.newId();
+  const startedAt = new Date().toISOString();
+  initAuditLogger(runId, options?.onAuditEvent);
+
+  // Mark run as in-progress so abrupt kills leave a trace
+  try { store?.markRunning(runId, absPath); } catch { /* non-fatal */ }
+
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`Workflow file not found: ${absPath}`);
+  }
+
+  const config = resolveWeaverConfig(absPath, options?.config);
+  const providerConfig = resolveProviderConfig(config.provider);
+  const approvalConfig = resolveApproval(config.approval);
+  const notifyConfigs = resolveNotify(config.notify);
+
+  const provider = await createProvider(providerConfig);
+
+  const costTracker = new CostTracker(providerConfig.model ?? 'unknown', providerConfig.name);
+  provider.onUsage = (step, model, usage) => costTracker.track(step, model, usage);
+  const channels = notifyConfigs.map(
+    (c) => new WebhookNotificationChannel(c, options?.onNotificationError),
+  );
+  const notifier = createNotifier(channels);
+
+  const projectDir = path.dirname(absPath);
+
+  if (verbose) {
+    console.log(`[weaver] Workflow: ${absPath}`);
+    const providerLabel = providerConfig.model
+      ? `${providerConfig.name} (${providerConfig.model})`
+      : providerConfig.name;
+    console.log(`[weaver] Provider: ${providerLabel}`);
+    console.log(`[weaver] Approval: ${approvalConfig.mode}`);
+    console.log(`[weaver] Notifications: ${channels.length} channel(s)`);
+  }
+
+  auditEmit('run-start', { workflowFile: absPath, provider: providerConfig.name, projectDir });
+
+  await notifier({
+    type: 'workflow-start',
+    workflowFile: absPath,
+    projectDir,
+  });
+
+  const botChannel = new BotAgentChannel(provider, {
+    approvalMode: approvalConfig.mode,
+    approvalTimeoutSeconds: approvalConfig.timeoutSeconds,
+    approvalWebhookUrl: approvalConfig.webhookUrl,
+    approvalWebOpen: approvalConfig.webOpen,
+    dashboardServer: options?.dashboardServer,
+    notifier,
+    context: { projectDir, workflowFile: absPath },
+  });
+
+  try {
+    const mod = '@synergenius/flow-weaver/executor';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { executeWorkflowFromFile } = await (import(mod) as Promise<any>);
+
+    if (options?.dryRun) {
+      if (verbose) console.log('[weaver] Dry run, skipping execution');
+      const dryResult: WorkflowResult = { success: true, summary: 'Dry run', outcome: 'skipped' };
+      recordRun(store, { id: runId, workflowFile: absPath, startedAt, success: true, outcome: 'skipped', summary: 'Dry run', dryRun: true, provider: providerConfig.name, params: options?.params }, verbose);
+      return dryResult;
+    }
+
+    // Forward trace events as ExecutionEvents
+    const onTraceEvent = options?.onEvent
+      ? (traceEvent: { type: string; timestamp: number; data?: Record<string, unknown> }) => {
+          if (traceEvent.type !== 'STATUS_CHANGED' || !traceEvent.data) return;
+          const nodeId = traceEvent.data.id as string | undefined;
+          const status = traceEvent.data.status as string | undefined;
+          if (!nodeId || !status) return;
+
+          let eventType: ExecutionEvent['type'] | null = null;
+          if (status === 'RUNNING') eventType = 'node-start';
+          else if (status === 'SUCCEEDED') eventType = 'node-complete';
+          else if (status === 'FAILED') eventType = 'node-error';
+
+          if (eventType) {
+            options.onEvent!({
+              type: eventType,
+              nodeId,
+              nodeType: traceEvent.data.nodeTypeName as string | undefined,
+              timestamp: traceEvent.timestamp,
+              error: traceEvent.data.error as string | undefined,
+            });
+          }
+        }
+      : undefined;
+
+    const execResult = await executeWorkflowFromFile(
+      absPath,
+      options?.params ?? {},
+      {
+        agentChannel: botChannel,
+        includeTrace: !!onTraceEvent,
+        production: !onTraceEvent,
+        onEvent: onTraceEvent,
+      },
+    );
+
+    const result = execResult.result as Record<string, unknown> | null;
+    const success = (result?.onSuccess as boolean) ?? false;
+    const summary = buildSummary(result);
+    const outcome = success ? 'completed' : 'failed';
+
+    await notifier({
+      type: 'workflow-complete',
+      workflowFile: absPath,
+      projectDir,
+      summary,
+      outcome,
+    });
+
+    const costSummary = costTracker.hasEntries() ? costTracker.getRunSummary() : undefined;
+    persistCost(costSummary, absPath, providerConfig.name, verbose);
+    recordRun(store, {
+      id: runId, workflowFile: absPath, startedAt, success, outcome: outcome as RunOutcome, summary,
+      functionName: execResult.functionName, executionTime: execResult.executionTime,
+      dryRun: false, provider: providerConfig.name, params: options?.params,
+    }, verbose);
+
+    auditEmit('run-complete', { success, outcome, summary });
+
+    return {
+      success,
+      summary,
+      outcome,
+      functionName: execResult.functionName,
+      executionTime: execResult.executionTime,
+      cost: costSummary,
+    };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+
+    await notifier({
+      type: 'error',
+      workflowFile: absPath,
+      projectDir,
+      error: msg,
+    });
+
+    const costSummary = costTracker.hasEntries() ? costTracker.getRunSummary() : undefined;
+    persistCost(costSummary, absPath, providerConfig.name, verbose);
+    recordRun(store, {
+      id: runId, workflowFile: absPath, startedAt, success: false, outcome: 'error', summary: msg,
+      dryRun: options?.dryRun ?? false, provider: providerConfig.name, params: options?.params,
+    }, verbose);
+
+    auditEmit('run-complete', { success: false, error: msg });
+
+    return { success: false, summary: msg, outcome: 'error', cost: costSummary };
+  } finally {
+    teardownAuditLogger();
+  }
+}
+
+function recordRun(
+  store: RunStore | null,
+  data: {
+    id: string; workflowFile: string; startedAt: string; success: boolean;
+    outcome: RunOutcome; summary: string; functionName?: string;
+    executionTime?: number; dryRun: boolean; provider?: string;
+    params?: Record<string, unknown>;
+  },
+  verbose: boolean,
+): void {
+  if (!store) return;
+  const finishedAt = new Date().toISOString();
+  try {
+    store.append({
+      ...data,
+      finishedAt,
+      durationMs: new Date(finishedAt).getTime() - new Date(data.startedAt).getTime(),
+    });
+    store.clearRunning(data.id);
+  } catch (err) {
+    if (verbose) console.error(`[weaver] Failed to record run history: ${err}`);
+  }
+}
+
+function persistCost(
+  costSummary: import('./types.js').RunCostSummary | undefined,
+  workflowFile: string,
+  provider: string,
+  verbose: boolean,
+): void {
+  if (!costSummary || costSummary.totalInputTokens === 0) return;
+  try {
+    new CostStore().append({
+      timestamp: Date.now(),
+      workflowFile,
+      provider,
+      model: costSummary.model,
+      inputTokens: costSummary.totalInputTokens,
+      outputTokens: costSummary.totalOutputTokens,
+      estimatedCost: costSummary.totalCost,
+      steps: costSummary.entries.length,
+    });
+  } catch (err) {
+    if (verbose) console.error(`[weaver] Failed to persist cost data: ${err}`);
+  }
+}

package/src/bot/session-state.ts

@@ -0,0 +1,73 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as crypto from 'node:crypto';
+import { withFileLock } from './file-lock.js';
+
+export interface SessionState {
+  sessionId: string;
+  status: 'idle' | 'planning' | 'executing' | 'validating' | 'waiting-approval' | 'paused' | 'fixing';
+  currentTask: string | null;
+  completedTasks: number;
+  totalCost: number;
+  startedAt: number;
+  lastActivity: number;
+}
+
+export class SessionStore {
+  private filePath: string;
+
+  constructor(dir?: string) {
+    const base = dir ?? path.join(os.homedir(), '.weaver');
+    this.filePath = path.join(base, 'session.json');
+  }
+
+  async create(): Promise<SessionState> {
+    const state: SessionState = {
+      sessionId: crypto.randomUUID().slice(0, 8),
+      status: 'idle',
+      currentTask: null,
+      completedTasks: 0,
+      totalCost: 0,
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+    };
+    await this.save(state);
+    return state;
+  }
+
+  load(): SessionState | null {
+    try {
+      if (!fs.existsSync(this.filePath)) return null;
+      return JSON.parse(fs.readFileSync(this.filePath, 'utf-8')) as SessionState;
+    } catch {
+      return null;
+    }
+  }
+
+  async save(state: SessionState): Promise<void> {
+    return withFileLock(this.filePath, () => {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      state.lastActivity = Date.now();
+      fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2), 'utf-8');
+    });
+  }
+
+  async update(patch: Partial<SessionState>): Promise<SessionState | null> {
+    return withFileLock(this.filePath, () => {
+      const state = this.load();
+      if (!state) return null;
+      Object.assign(state, patch);
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      state.lastActivity = Date.now();
+      fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2), 'utf-8');
+      return state;
+    });
+  }
+
+  clear(): void {
+    try { fs.unlinkSync(this.filePath); } catch { /* ignore */ }
+  }
+}

package/src/bot/steering.ts

@@ -0,0 +1,44 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { withFileLock } from './file-lock.js';
+
+export interface SteeringCommand {
+  command: 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue';
+  payload?: string;
+  timestamp: number;
+}
+
+export class SteeringController {
+  private controlPath: string;
+
+  constructor(controlDir?: string) {
+    const dir = controlDir ?? path.join(os.homedir(), '.weaver');
+    this.controlPath = path.join(dir, 'control.json');
+  }
+
+  async check(): Promise<SteeringCommand | null> {
+    return withFileLock(this.controlPath, () => {
+      try {
+        if (!fs.existsSync(this.controlPath)) return null;
+        const raw = fs.readFileSync(this.controlPath, 'utf-8');
+        fs.unlinkSync(this.controlPath);
+        return JSON.parse(raw) as SteeringCommand;
+      } catch {
+        return null;
+      }
+    });
+  }
+
+  async write(command: SteeringCommand): Promise<void> {
+    return withFileLock(this.controlPath, () => {
+      const dir = path.dirname(this.controlPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this.controlPath, JSON.stringify(command, null, 2), 'utf-8');
+    });
+  }
+
+  clear(): void {
+    try { fs.unlinkSync(this.controlPath); } catch { /* ignore */ }
+  }
+}

package/src/bot/step-executor.ts

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { runCommand } from '@synergenius/flow-weaver';
+
+export async function executeStep(
+  step: { operation: string; args: Record<string, unknown> },
+  projectDir: string,
+): Promise<{ file?: string; files?: string[]; created?: boolean; output?: string }> {
+  const args = step.args;
+  const file = args.file as string | undefined;
+
+  switch (step.operation) {
+    case 'write-file':
+    case 'create-workflow':
+    case 'modify-source':
+    case 'implement-node': {
+      const filePath = path.resolve(projectDir, file!);
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      const existed = fs.existsSync(filePath);
+      fs.writeFileSync(filePath, (args.content as string) ?? (args.body as string) ?? '', 'utf-8');
+      return { file: filePath, created: !existed };
+    }
+    case 'read-file':
+      return {};
+    default: {
+      const result = await runCommand(step.operation, { ...args, cwd: projectDir });
+      return {
+        file: result.files?.[0],
+        files: result.files,
+        output: result.output ?? (result.data ? JSON.stringify(result.data, null, 2) : undefined),
+      };
+    }
+  }
+}