Temporal Orchestration

export async function pentestPipelineWorkflow(
  input: PipelineInput
): Promise<PipelineState> {
  const state: PipelineState = {
    status: 'running',
    currentPhase: null,
    currentAgent: null,
    completedAgents: [],
    failedAgent: null,
    error: null,
    startTime: Date.now(),
    agentMetrics: {},
    summary: null,
  };
  
  // Enable progress queries
  setHandler(getProgress, (): PipelineProgress => ({
    ...state,
    workflowId,
    elapsedMs: Date.now() - state.startTime,
  }));
  
  // Execute phases
  await runSequentialPhase('pre-recon', 'pre-recon', a.runPreReconAgent);
  await runSequentialPhase('recon', 'recon', a.runReconAgent);
  
  const pipelineResults = await runWithConcurrencyLimit(pipelineThunks, maxConcurrent);
  
  await runSequentialPhase('reporting', 'report', a.runReportAgent);
  
  state.status = 'completed';
  return state;
}

export async function runReconAgent(
  input: ActivityInput
): Promise<AgentMetrics> {
  // Delegate to service layer
  return await executeAgent({
    agentName: 'recon',
    activityInput: input,
  });
}

export async function runInjectionVulnAgent(
  input: ActivityInput  
): Promise<AgentMetrics> {
  return await executeAgent({
    agentName: 'injection-vuln',
    activityInput: input,
  });
}

// Define query in workflow
setHandler(getProgress, (): PipelineProgress => ({
  ...state,
  workflowId,
  elapsedMs: Date.now() - state.startTime,
}));

# Query from CLI
./shannon query ID=shannon-1234567890

{
  "status": "running",
  "currentPhase": "vulnerability-exploitation",
  "currentAgent": "pipelines",
  "completedAgents": ["pre-recon", "recon"],
  "elapsedMs": 1847293,
  "agentMetrics": {
    "pre-recon": { "costUsd": 2.45, "durationMs": 892341 },
    "recon": { "costUsd": 1.87, "durationMs": 954952 }
  }
}

# Start a pentest
./shannon start URL=https://example.com REPO=my-app WORKSPACE=audit-q1
# -> Workflow ID: shannon-1234567890
# -> Runs pre-recon, recon, starts vuln analysis...
# -> Interrupted! (Ctrl+C, crash, etc.)

# List workspaces to find the ID
./shannon workspaces
# Output:
# example-com_audit-q1 (2 of 13 agents complete)

# Resume from where it left off
./shannon start URL=https://example.com REPO=my-app WORKSPACE=audit-q1
# -> Skips pre-recon and recon
# -> Continues with vuln analysis

# View real-time logs
./shannon logs

# Query specific workflow
./shannon query ID=shannon-1234567890

# List all workspaces
./shannon workspaces

audit-logs/example-com_shannon-1234/
├── session.json              # Session metadata and metrics
├── workflow.log              # Human-readable workflow log
├── agents/
│   ├── pre-recon.log        # Per-agent execution logs
│   ├── recon.log
│   └── injection-vuln.log
├── prompts/
│   ├── pre-recon.txt        # Prompt snapshots for reproducibility
│   └── recon.txt
└── deliverables/
    ├── code_analysis_deliverable.md
    └── recon_deliverable.md

import { Connection, Client } from '@temporalio/client';

export async function startPentestWorkflow(
  input: PipelineInput
): Promise<string> {
  const connection = await Connection.connect({
    address: 'localhost:7233',
  });
  
  const client = new Client({ connection });
  
  const workflowId = `shannon-${Date.now()}`;
  
  const handle = await client.workflow.start(pentestPipelineWorkflow, {
    taskQueue: 'shannon-pentest',
    workflowId,
    args: [input],
  });
  
  return workflowId;
}

import { Worker } from '@temporalio/worker';
import * as activities from './activities.js';

async function run() {
  const worker = await Worker.create({
    workflowsPath: require.resolve('./workflows'),
    activities,
    taskQueue: 'shannon-pentest',
  });
  
  await worker.run();
}

run().catch((err) => {
  console.error(err);
  process.exit(1);
});