@archznn/crewloop-skills 0.3.0 → 0.4.1

package/servers/dashboard/src/adapters/kimi.ts

@@ -0,0 +1,40 @@
+import type { AgentSource, DashboardEvent, EventType } from '../types';
+
+export interface KimiHookPayload {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_response?: Record<string, unknown>;
+  stop_reason?: string;
+  usage?: unknown;
+}
+
+const EVENT_MAP: Record<string, EventType> = {
+  PreToolUse: 'tool_start',
+  PostToolUse: 'tool_end',
+  SessionStart: 'session_start',
+  SessionEnd: 'session_end',
+  Stop: 'session_end',
+};
+
+export function normalizeKimi(payload: KimiHookPayload): DashboardEvent | undefined {
+  const event_type = EVENT_MAP[payload.hook_event_name];
+  if (!event_type) {
+    return undefined;
+  }
+
+  return {
+    id: generateId(),
+    timestamp: Date.now(),
+    source: 'kimi' as AgentSource,
+    session_id: payload.session_id || 'unknown',
+    event_type,
+    tool: payload.tool_name,
+  };
+}
+
+function generateId(): string {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}

package/servers/dashboard/src/adapters/opencode.ts

@@ -0,0 +1,36 @@
+import type { AgentSource, DashboardEvent, EventType, EventStatus } from '../types';
+
+export interface OpenCodeToolEvent {
+  tool: string;
+  args?: Record<string, unknown>;
+  duration?: number;
+  success?: boolean;
+}
+
+export function createOpenCodeEvent(
+  sessionId: string,
+  eventType: EventType,
+  data: OpenCodeToolEvent
+): DashboardEvent {
+  let status: EventStatus | undefined;
+  if (eventType === 'tool_end') {
+    status = data.success === false ? 'error' : 'success';
+  } else if (eventType === 'tool_start') {
+    status = 'running';
+  }
+
+  return {
+    id: generateId(),
+    timestamp: Date.now(),
+    source: 'opencode' as AgentSource,
+    session_id: sessionId,
+    event_type: eventType,
+    tool: data.tool,
+    status,
+    duration_ms: data.duration,
+  };
+}
+
+function generateId(): string {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}

package/servers/dashboard/src/adapters/shim.test.ts

@@ -0,0 +1,74 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { detectSource, buildEvent } from './shim';
+import type { AgentSource, DashboardEvent } from '../types';
+
+describe('detectSource', () => {
+  it('detects source from argv', () => {
+    assert.equal(detectSource(['node', 'shim', 'kimi']), 'kimi');
+    assert.equal(detectSource(['node', 'shim', 'codex']), 'codex');
+  });
+
+  it('falls back to env var', () => {
+    process.env.CREWLOOP_DASHBOARD_SOURCE = 'opencode';
+    assert.equal(detectSource(['node', 'shim']), 'opencode');
+    delete process.env.CREWLOOP_DASHBOARD_SOURCE;
+  });
+
+  it('returns undefined when unknown', () => {
+    assert.equal(detectSource(['node', 'shim', 'unknown']), undefined);
+  });
+});
+
+describe('buildEvent', () => {
+  it('builds Kimi PreToolUse event', () => {
+    const event = buildEvent('kimi' as AgentSource, {
+      hook_event_name: 'PreToolUse',
+      session_id: 'sess-1',
+      cwd: '/project',
+      tool_name: 'Read',
+      tool_input: { path: 'README.md' },
+    });
+    assert.equal(event?.event_type, 'tool_start');
+    assert.equal(event?.tool, 'Read');
+    assert.equal(event?.detail, 'README.md');
+    assert.equal(event?.status, 'running');
+  });
+
+  it('builds Kimi PostToolUse event with status', () => {
+    const event = buildEvent('kimi' as AgentSource, {
+      hook_event_name: 'PostToolUse',
+      session_id: 'sess-1',
+      cwd: '/project',
+      tool_name: 'Read',
+      tool_input: { path: 'README.md' },
+      tool_response: { success: true, duration_ms: 12 },
+    });
+    assert.equal(event?.event_type, 'tool_end');
+    assert.equal(event?.status, 'success');
+    assert.equal(event?.duration_ms, 12);
+  });
+
+  it('builds Codex event', () => {
+    const event = buildEvent('codex' as AgentSource, {
+      sessionId: 'sess-2',
+      toolName: 'Bash',
+      toolInput: { command: 'ls' },
+      toolResponse: { success: true, durationMs: 5 },
+    });
+    assert.equal(event?.source, 'codex');
+    assert.equal(event?.tool, 'Bash');
+    assert.equal(event?.detail, undefined);
+    assert.equal(event?.status, 'success');
+    assert.equal(event?.duration_ms, 5);
+  });
+
+  it('returns undefined for unsupported hook event', () => {
+    const event = buildEvent('kimi' as AgentSource, {
+      hook_event_name: 'UnknownEvent',
+      session_id: 'sess-1',
+      cwd: '/project',
+    });
+    assert.equal(event, undefined);
+  });
+});

package/servers/dashboard/src/adapters/shim.ts

@@ -0,0 +1,120 @@
+import http from 'node:http';
+import type { AgentSource, DashboardEvent } from '../types';
+import { normalizeKimi, type KimiHookPayload } from './kimi';
+import { normalizeCodex, type CodexHookPayload } from './codex';
+import { sanitize } from '../filters/sanitize';
+
+const DEFAULT_SERVER_URL = 'http://127.0.0.1:7890';
+
+export function detectSource(argv: string[]): AgentSource | undefined {
+  const arg = argv[2];
+  if (arg === 'kimi' || arg === 'codex' || arg === 'opencode' || arg === 'log-watcher') {
+    return arg;
+  }
+  const env = process.env.CREWLOOP_DASHBOARD_SOURCE;
+  if (
+    env === 'kimi' ||
+    env === 'codex' ||
+    env === 'opencode' ||
+    env === 'log-watcher'
+  ) {
+    return env;
+  }
+  return undefined;
+}
+
+export function normalizePayload(source: AgentSource, raw: unknown): DashboardEvent | undefined {
+  if (typeof raw !== 'object' || raw === null) {
+    return undefined;
+  }
+
+  const payload = raw as Record<string, unknown>;
+
+  switch (source) {
+    case 'kimi':
+      return normalizeKimi(payload as unknown as KimiHookPayload);
+    case 'codex':
+      return normalizeCodex(payload as unknown as CodexHookPayload);
+    default:
+      return undefined;
+  }
+}
+
+export function buildEvent(
+  source: AgentSource,
+  raw: Record<string, unknown>
+): DashboardEvent | undefined {
+  const base = normalizePayload(source, raw);
+  if (!base) {
+    return undefined;
+  }
+
+  const isPost = base.event_type === 'tool_end';
+  const sanitized = sanitize(
+    {
+      tool_name: base.tool || '',
+      tool_input: (raw.tool_input || raw.toolInput) as Record<string, unknown> | undefined,
+      tool_response: (raw.tool_response || raw.toolResponse) as Record<string, unknown> | undefined,
+    },
+    isPost ? 'post' : 'pre'
+  );
+
+  return {
+    ...base,
+    detail: sanitized.detail,
+    status: sanitized.status,
+    duration_ms: sanitized.duration_ms,
+  };
+}
+
+export function postEvent(event: DashboardEvent): void {
+  const serverUrl = process.env.CREWLOOP_DASHBOARD_URL || DEFAULT_SERVER_URL;
+  const body = JSON.stringify(event);
+
+  const url = new URL('/event', serverUrl);
+  const req = http.request(
+    {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 300,
+    },
+    () => {}
+  );
+
+  req.on('error', () => {});
+  req.on('timeout', () => req.destroy());
+  req.write(body);
+  req.end();
+}
+
+export function runShim(): void {
+  const source = detectSource(process.argv);
+  if (!source) {
+    process.stderr.write('crewloop-shim: unknown source. Use: crewloop-shim <kimi|codex>\n');
+    process.exit(1);
+  }
+
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => {
+    raw += chunk;
+  });
+  process.stdin.on('end', () => {
+    try {
+      const payload = JSON.parse(raw);
+      const event = buildEvent(source, payload);
+      if (event) {
+        postEvent(event);
+      }
+    } catch {
+      // Fail silently so the agent is never blocked.
+    }
+    process.exit(0);
+  });
+}

package/servers/dashboard/src/api/event.ts

@@ -0,0 +1,70 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { DashboardEvent, ClientWebSocketMessage } from '../types';
+import { StateStore } from '../state';
+import { SkillInferenceEngine } from '../skills/infer';
+import { sanitizeEventBoundary } from '../filters/sanitize';
+import { createUpdateMessage } from '../presenter';
+
+export interface EventHandlerDependencies {
+  state: StateStore;
+  inference: SkillInferenceEngine;
+  broadcast: (message: ClientWebSocketMessage) => void;
+  getActiveSessionId: () => string | undefined;
+  setActiveSessionId: (id: string) => void;
+}
+
+export function createEventHandler(deps: EventHandlerDependencies) {
+  return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    if (req.method !== 'POST') {
+      res.statusCode = 405;
+      res.end(JSON.stringify({ error: 'Method not allowed' }));
+      return;
+    }
+
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      body += chunk;
+    });
+
+    await new Promise<void>((resolve) => {
+      req.on('end', resolve);
+    });
+
+    let event: DashboardEvent;
+    try {
+      event = JSON.parse(body) as DashboardEvent;
+    } catch {
+      res.statusCode = 400;
+      res.end(JSON.stringify({ error: 'Invalid JSON' }));
+      return;
+    }
+
+    if (!sanitizeEventBoundary(event as unknown as Record<string, unknown>)) {
+      res.statusCode = 400;
+      res.end(JSON.stringify({ error: 'Event contains unsafe fields' }));
+      return;
+    }
+
+    if (!event.session_id || !event.event_type) {
+      res.statusCode = 400;
+      res.end(JSON.stringify({ error: 'Missing required fields' }));
+      return;
+    }
+
+    const session = deps.state.applyEvent(event);
+    const inferred = deps.inference.infer(event, session);
+
+    if (inferred.skill !== session.active_skill || inferred.confidence !== session.active_confidence) {
+      deps.state.setActiveSkill(session.id, inferred.skill, inferred.confidence);
+    }
+
+    const updatedSession = deps.state.getSession(session.id)!;
+    deps.setActiveSessionId(updatedSession.id);
+
+    deps.broadcast(createUpdateMessage(updatedSession, deps.getActiveSessionId()));
+
+    res.statusCode = 200;
+    res.end(JSON.stringify({ ok: true }));
+  };
+}

package/servers/dashboard/src/api/skills.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { SkillRegistry } from '../skills/registry';
+
+export function createSkillsHandler(registry: SkillRegistry) {
+  return async (_req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    const skills = registry.getSkills();
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify(skills));
+  };
+}

package/servers/dashboard/src/config.ts

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import type { ServerConfig } from './types';
+
+export const SAFE_TOOL_INPUT_KEYS = new Set([
+  'path',
+  'file_path',
+  'skill',
+  'subagent_type',
+  'url',
+]);
+
+export const DANGEROUS_TOOL_INPUT_KEYS = new Set([
+  'command',
+  'content',
+  'text',
+  'code',
+  'prompt',
+  'api_key',
+  'token',
+  'password',
+  'secret',
+  'key',
+  'authorization',
+]);
+
+export const DEFAULT_PORT = 7890;
+export const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_MAX_EVENTS = 200;
+export const DEFAULT_SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_PRUNE_INTERVAL_MS = 60 * 1000;
+
+export function loadConfig(): ServerConfig {
+  const port = parseInt(process.env.CREWLOOP_DASHBOARD_PORT || String(DEFAULT_PORT), 10);
+  const host = process.env.CREWLOOP_DASHBOARD_HOST || DEFAULT_HOST;
+
+  return {
+    port,
+    host,
+    packageRoot: resolvePackageRoot(),
+    maxEventsPerSession: DEFAULT_MAX_EVENTS,
+    sessionMaxAgeMs: DEFAULT_SESSION_MAX_AGE_MS,
+    pruneIntervalMs: DEFAULT_PRUNE_INTERVAL_MS,
+  };
+}
+
+export function resolvePackageRoot(): string {
+  try {
+    const skillsPackageJson = require.resolve('@archznn/crewloop-skills/package.json');
+    return path.dirname(skillsPackageJson);
+  } catch {
+    const cwdNodeModules = path.join(process.cwd(), 'node_modules', '@archznn', 'crewloop-skills');
+    if (fs.existsSync(path.join(cwdNodeModules, 'package.json'))) {
+      return cwdNodeModules;
+    }
+  }
+
+  const monorepoRoot = path.resolve(__dirname, '..', '..', '..');
+  if (fs.existsSync(path.join(monorepoRoot, 'skills', 'orchestrator', 'SKILL.md'))) {
+    return monorepoRoot;
+  }
+
+  throw new Error(
+    'Could not find CrewLoop skills package. Install @archznn/crewloop-skills or run from the CrewLoop repository.'
+  );
+}

package/servers/dashboard/src/filters/sanitize.test.ts

@@ -0,0 +1,94 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { sanitize, sanitizeEventBoundary } from './sanitize';
+
+describe('sanitize', () => {
+  it('extracts safe path details', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Read',
+        tool_input: { path: 'README.md' },
+      },
+      'pre'
+    );
+    assert.equal(result.detail, 'README.md');
+    assert.equal(result.status, 'running');
+  });
+
+  it('extracts skill name from Skill tool input', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Skill',
+        tool_input: { skill: 'architect' },
+      },
+      'pre'
+    );
+    assert.equal(result.detail, 'architect');
+  });
+
+  it('strips dangerous command input', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Bash',
+        tool_input: { command: 'rm -rf /' },
+      },
+      'pre'
+    );
+    assert.equal(result.detail, undefined);
+    assert.equal(result.status, 'running');
+  });
+
+  it('strips content/text input', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Write',
+        tool_input: { path: 'secret.env', content: 'API_KEY=123' },
+      },
+      'pre'
+    );
+    assert.equal(result.detail, 'secret.env');
+  });
+
+  it('marks success on post event', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Read',
+        tool_input: { path: 'README.md' },
+        tool_response: { success: true, duration_ms: 12 },
+      },
+      'post'
+    );
+    assert.equal(result.status, 'success');
+    assert.equal(result.duration_ms, 12);
+  });
+
+  it('marks error on post event', () => {
+    const result = sanitize(
+      {
+        tool_name: 'Bash',
+        tool_response: { success: false, durationMs: 45 },
+      },
+      'post'
+    );
+    assert.equal(result.status, 'error');
+    assert.equal(result.duration_ms, 45);
+  });
+
+  it('extracts hostname from safe url input', () => {
+    const result = sanitize(
+      {
+        tool_name: 'FetchURL',
+        tool_input: { url: 'https://example.com/path' },
+      },
+      'pre'
+    );
+    assert.equal(result.detail, 'example.com');
+    assert.equal(result.status, 'running');
+  });
+
+  it('rejects events with dangerous keys at boundary', () => {
+    assert.equal(sanitizeEventBoundary({ command: 'ls' }), false);
+    assert.equal(sanitizeEventBoundary({ token: 'abc' }), false);
+    assert.equal(sanitizeEventBoundary({ path: 'README.md' }), true);
+  });
+});

package/servers/dashboard/src/filters/sanitize.ts

@@ -0,0 +1,78 @@
+import { SAFE_TOOL_INPUT_KEYS, DANGEROUS_TOOL_INPUT_KEYS } from '../config';
+import type { EventStatus } from '../types';
+
+export interface SanitizeInput {
+  tool_name: string;
+  tool_input?: Record<string, unknown>;
+  tool_response?: Record<string, unknown>;
+}
+
+export interface SafeDetail {
+  detail?: string;
+  status?: EventStatus;
+  duration_ms?: number;
+}
+
+function extractSafeDetail(input: Record<string, unknown>): string | undefined {
+  for (const [key, value] of Object.entries(input)) {
+    const lower = key.toLowerCase();
+    if (!SAFE_TOOL_INPUT_KEYS.has(lower)) {
+      continue;
+    }
+    if (typeof value === 'string') {
+      if (lower === 'url') {
+        try {
+          const url = new URL(value);
+          return url.hostname;
+        } catch {
+          return undefined;
+        }
+      }
+      return value;
+    }
+  }
+  return undefined;
+}
+
+export function sanitize(input: SanitizeInput, event: 'pre' | 'post'): SafeDetail {
+  const result: SafeDetail = {};
+
+  if (input.tool_input) {
+    const detail = extractSafeDetail(input.tool_input);
+    if (detail) {
+      result.detail = detail;
+    }
+  }
+
+  if (event === 'post' && input.tool_response && typeof input.tool_response === 'object') {
+    const response = input.tool_response as Record<string, unknown>;
+
+    if (typeof response.duration_ms === 'number') {
+      result.duration_ms = response.duration_ms;
+    } else if (typeof response.durationMs === 'number') {
+      result.duration_ms = response.durationMs;
+    }
+
+    if (response.is_error === true || response.success === false || response.error) {
+      result.status = 'error';
+    } else if (response.success === true || response.is_error === false) {
+      result.status = 'success';
+    }
+  }
+
+  if (event === 'pre') {
+    result.status = 'running';
+  }
+
+  return result;
+}
+
+export function sanitizeEventBoundary(payload: Record<string, unknown>): boolean {
+  const keys = Object.keys(payload);
+  for (const key of keys) {
+    if (DANGEROUS_TOOL_INPUT_KEYS.has(key.toLowerCase())) {
+      return false;
+    }
+  }
+  return true;
+}

package/servers/dashboard/src/index.ts

@@ -0,0 +1,24 @@
+import { loadConfig } from './config';
+import { createDashboardServer } from './server';
+
+async function main(): Promise<void> {
+  const config = loadConfig();
+  const server = createDashboardServer(config);
+
+  process.on('SIGINT', async () => {
+    await server.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', async () => {
+    await server.stop();
+    process.exit(0);
+  });
+
+  await server.start();
+}
+
+main().catch((err) => {
+  console.error('Failed to start dashboard:', err);
+  process.exit(1);
+});

package/servers/dashboard/src/presenter.test.ts

@@ -0,0 +1,69 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { presentSession, presentState, createSnapshotMessage, createUpdateMessage } from './presenter';
+import type { Session, ClientUpdateMessage } from './types';
+
+function makeSession(overrides: Partial<Session> = {}): Session {
+  return {
+    id: 'sess-1',
+    source: 'kimi',
+    events: [],
+    tool_counts: { Read: 2 },
+    started_at: 1000,
+    last_event_at: 2000,
+    active_skill: 'architect',
+    active_confidence: 'explicit',
+    status: 'running',
+    ...overrides,
+  };
+}
+
+describe('presenter', () => {
+  it('converts session to client shape', () => {
+    const session = makeSession();
+    const client = presentSession(session);
+
+    assert.equal(client.id, 'sess-1');
+    assert.equal(client.source, 'kimi');
+    assert.equal(client.skill, 'architect');
+    assert.deepEqual(client.activeSkill, { name: 'architect', confidence: 'explicit' });
+    assert.equal(client.status, 'running');
+    assert.equal(client.startTime, 1000);
+    assert.equal(client.lastActivity, 2000);
+    assert.deepEqual(client.toolCounts, { Read: 2 });
+  });
+
+  it('omits active skill when not set', () => {
+    const client = presentSession(makeSession({ active_skill: undefined }));
+    assert.equal(client.activeSkill, undefined);
+    assert.equal(client.skill, undefined);
+  });
+
+  it('presents state as client sessions', () => {
+    const state = {
+      sessions: {
+        'sess-1': makeSession(),
+      },
+    };
+    const sessions = presentState(state);
+    assert.equal(sessions.length, 1);
+    assert.equal(sessions[0].id, 'sess-1');
+  });
+
+  it('creates snapshot message', () => {
+    const message = createSnapshotMessage([makeSession()]);
+    assert.equal(message.type, 'snapshot');
+    assert.equal(message.sessions.length, 1);
+    assert.equal(message.sessions[0].id, 'sess-1');
+  });
+
+  it('creates update message with isActive flag', () => {
+    const message = createUpdateMessage(makeSession(), 'sess-1') as ClientUpdateMessage;
+    assert.equal(message.type, 'update');
+    assert.equal(message.session.id, 'sess-1');
+    assert.equal(message.isActive, true);
+
+    const inactive = createUpdateMessage(makeSession(), 'sess-2') as ClientUpdateMessage;
+    assert.equal(inactive.isActive, false);
+  });
+});