@crewx/shared 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@crewx/shared",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "skill-tracer.js",
-  "description": "Shared utilities for CrewX built-in packages"
+  "description": "Shared utilities for CrewX built-in packages",
+  "dependencies": {
+    "@crewx/sdk": "*"
+  }
 }

package/skill-tracer.d.ts

@@ -1,4 +1,23 @@
 declare const tracer: {
   run: (name: string, fn: () => any, opts?: any) => Promise<any>;
+  trace: (
+    skillName: string,
+    command: string,
+    options?: {
+      agentId?: string;
+      usageLog?: string;
+      tracesDb?: boolean;
+      skillVersion?: string;
+    }
+  ) => {
+    taskId: string | null;
+    spanId?: string;
+    ok: (result?: string | null, meta?: { stderr?: string }) => void;
+    fail: (error: string, meta?: { stderr?: string }) => void;
+    _skipped: boolean;
+  } | null;
+  getDbPath: () => string;
+  getTracesDbPath: () => string;
+  getOwnSkillVersion: (skillDir: string) => string | null;
 };
 export = tracer;

package/skill-tracer.js

@@ -6,7 +6,7 @@
  * - crewx.db: SQLite DB 로그 (상세)
  */
 
-// Lazy-load better-sqlite3 to allow graceful degradation if not installed
+// Lazy-load better-sqlite3 (native prebuild, no WASM)
 let Database;
 try {
   Database = require('better-sqlite3');
@@ -17,7 +17,8 @@ try {
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
-const { randomUUID, createHash } = require('crypto');
+const { createHash } = require('crypto');
+const { generateId } = require('@crewx/sdk');
 
 /**
  * crewx.db 경로 찾기
@@ -48,7 +49,9 @@ function getDb() {
   }
 
   const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA busy_timeout = 5000');
+  db.exec('PRAGMA foreign_keys = ON');
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS tasks (
@@ -246,11 +249,74 @@ function logToUsageFile(logPath, skillName, command) {
  * @param {boolean} [options.tracesDb=true] - crewx.db 기록 여부
  * @returns {{ taskId: string, ok: (result?: string) => void, fail: (error: string) => void }}
  */
+const _versionCache = new Map();
+
+function getOwnSkillVersion(skillDir) {
+  const resolved = path.resolve(skillDir);
+  if (_versionCache.has(resolved)) return _versionCache.get(resolved);
+
+  const candidates = [
+    path.join(resolved, 'SKILL.md'),
+    path.join(resolved, '..', 'SKILL.md'),
+  ];
+
+  for (const skillMdPath of candidates) {
+    try {
+      if (!fs.existsSync(skillMdPath)) continue;
+      const content = fs.readFileSync(skillMdPath, 'utf-8');
+      const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!fmMatch) continue;
+      const fm = fmMatch[1];
+      const versionMatch = fm.match(/^version:\s*(.+)$/m);
+      if (versionMatch) {
+        const v = versionMatch[1].trim().replace(/^['"]|['"]$/g, '');
+        _versionCache.set(resolved, v);
+        return v;
+      }
+      const nestedMatch = fm.match(/^\s+version:\s*(.+)$/m);
+      if (nestedMatch) {
+        const v = nestedMatch[1].trim().replace(/^['"]|['"]$/g, '');
+        _versionCache.set(resolved, v);
+        return v;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  _versionCache.set(resolved, null);
+  return null;
+}
+
+const MAX_OUTPUT_BYTES = 32 * 1024;
+const HALF_MAX = 16 * 1024;
+
+function truncateOutput(text) {
+  if (!text) return { text: null, truncated: false, originalBytes: 0 };
+
+  const buf = Buffer.from(text, 'utf-8');
+  const bytes = buf.length;
+
+  if (bytes <= MAX_OUTPUT_BYTES) {
+    return { text, truncated: false, originalBytes: bytes };
+  }
+
+  const headBuf = buf.subarray(0, HALF_MAX);
+  const tailBuf = buf.subarray(bytes - HALF_MAX);
+  const omitted = bytes - HALF_MAX * 2;
+
+  const marker = '\n...[omitted=' + omitted + ' bytes]...\n';
+  const result = headBuf.toString('utf-8') + marker + tailBuf.toString('utf-8');
+
+  return { text: result, truncated: true, originalBytes: bytes };
+}
+
 function trace(skillName, command, options = {}) {
   const {
     agentId,
     usageLog,
-    tracesDb = true
+    tracesDb = true,
+    skillVersion,
   } = typeof options === 'string' ? { agentId: options } : options;
 
   // usage.log 기록 (항상, 중복 상관없이)
@@ -299,43 +365,87 @@ function trace(skillName, command, options = {}) {
   // crewx skill x로 실행된 경우 → spans 테이블에 child span으로 기록
   const parentTaskId = process.env.CREWX_TASK_ID;
   if (parentTaskId && parentTaskId.trim() !== '') {
-    const spanId = randomUUID();
-    const attributes = JSON.stringify({
+    // Verify FK target exists before INSERT to avoid constraint error
+    const taskExists = db.prepare('SELECT 1 FROM tasks WHERE id = ?').get(parentTaskId);
+    const safeTaskId = taskExists ? parentTaskId : null;
+
+    const spanId = generateId('spn');
+    const attrs = {
       skill: skillName,
       agent_id: resolvedAgentId,
       tracer_version: '0.3.0'
-    });
+    };
+    if (skillVersion) attrs.skill_version = skillVersion;
+    const attributes = JSON.stringify(attrs);
 
     db.prepare(`
       INSERT INTO spans (id, task_id, name, kind, status, started_at, input, attributes)
       VALUES (?, ?, ?, 'internal', 'ok', ?, ?, ?)
-    `).run(spanId, parentTaskId, `[skill:${skillName}] ${command}`, now, command, attributes);
+    `).run(spanId, safeTaskId, skillName, now, command, attributes);
 
     return {
       taskId: parentTaskId,
       spanId,
-      ok: (result) => {
+      ok: (result, meta) => {
         const completedAt = new Date().toISOString();
+        const out = truncateOutput(result);
+        const attrs = JSON.parse(attributes);
+        if (out.truncated) {
+          attrs.output_truncated = true;
+          attrs.output_bytes_original = out.originalBytes;
+        }
+        if (meta && meta.stderr) {
+          const stderrOut = truncateOutput(meta.stderr);
+          attrs.stderr = stderrOut.text;
+          if (stderrOut.truncated) {
+            attrs.stderr_truncated = true;
+            attrs.stderr_bytes_original = stderrOut.originalBytes;
+          }
+        }
         db.prepare(`
           UPDATE spans
           SET status = 'ok',
               output = ?,
+              attributes = ?,
               completed_at = ?,
               duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
           WHERE id = ?
-        `).run(result || null, completedAt, completedAt, spanId);
+        `).run(out.text, JSON.stringify(attrs), completedAt, completedAt, spanId);
         db.close();
       },
-      fail: (error) => {
+      fail: (error, meta) => {
         const completedAt = new Date().toISOString();
-        db.prepare(`
-          UPDATE spans
-          SET status = 'error',
-              error = ?,
-              completed_at = ?,
-              duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
-          WHERE id = ?
-        `).run(error, completedAt, completedAt, spanId);
+        let updateAttrs = null;
+        if (meta && meta.stderr) {
+          const attrs = JSON.parse(attributes);
+          const stderrOut = truncateOutput(meta.stderr);
+          attrs.stderr = stderrOut.text;
+          if (stderrOut.truncated) {
+            attrs.stderr_truncated = true;
+            attrs.stderr_bytes_original = stderrOut.originalBytes;
+          }
+          updateAttrs = JSON.stringify(attrs);
+        }
+        if (updateAttrs) {
+          db.prepare(`
+            UPDATE spans
+            SET status = 'error',
+                error = ?,
+                attributes = ?,
+                completed_at = ?,
+                duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+            WHERE id = ?
+          `).run(error, updateAttrs, completedAt, completedAt, spanId);
+        } else {
+          db.prepare(`
+            UPDATE spans
+            SET status = 'error',
+                error = ?,
+                completed_at = ?,
+                duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+            WHERE id = ?
+          `).run(error, completedAt, completedAt, spanId);
+        }
         db.close();
       },
       _skipped: false
@@ -343,44 +453,84 @@ function trace(skillName, command, options = {}) {
   }
 
   // 직접 호출 (독립 실행) → spans 테이블에 task_id=NULL로 기록
-  const spanId = randomUUID();
-  const attributes = JSON.stringify({
+  const spanId = generateId('spn');
+  const attrs = {
     skill: skillName,
     agent_id: resolvedAgentId,
     direct_call: true,
     tracer_version: '0.3.0'
-  });
+  };
+  if (skillVersion) attrs.skill_version = skillVersion;
+  const attributes = JSON.stringify(attrs);
 
   db.prepare(`
     INSERT INTO spans (id, task_id, name, kind, status, started_at, input, attributes)
     VALUES (?, NULL, ?, 'internal', 'ok', ?, ?, ?)
-  `).run(spanId, `[skill:${skillName}] ${command}`, now, command, attributes);
+  `).run(spanId, skillName, now, command, attributes);
 
   return {
     taskId: null,
     spanId,
-    ok: (result) => {
+    ok: (result, meta) => {
       const completedAt = new Date().toISOString();
+      const out = truncateOutput(result);
+      const attrs = JSON.parse(attributes);
+      if (out.truncated) {
+        attrs.output_truncated = true;
+        attrs.output_bytes_original = out.originalBytes;
+      }
+      if (meta && meta.stderr) {
+        const stderrOut = truncateOutput(meta.stderr);
+        attrs.stderr = stderrOut.text;
+        if (stderrOut.truncated) {
+          attrs.stderr_truncated = true;
+          attrs.stderr_bytes_original = stderrOut.originalBytes;
+        }
+      }
       db.prepare(`
         UPDATE spans
         SET status = 'ok',
             output = ?,
+            attributes = ?,
             completed_at = ?,
             duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
         WHERE id = ?
-      `).run(result || null, completedAt, completedAt, spanId);
+      `).run(out.text, JSON.stringify(attrs), completedAt, completedAt, spanId);
       db.close();
     },
-    fail: (error) => {
+    fail: (error, meta) => {
       const completedAt = new Date().toISOString();
-      db.prepare(`
-        UPDATE spans
-        SET status = 'error',
-            error = ?,
-            completed_at = ?,
-            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
-        WHERE id = ?
-      `).run(error, completedAt, completedAt, spanId);
+      let updateAttrs = null;
+      if (meta && meta.stderr) {
+        const attrs = JSON.parse(attributes);
+        const stderrOut = truncateOutput(meta.stderr);
+        attrs.stderr = stderrOut.text;
+        if (stderrOut.truncated) {
+          attrs.stderr_truncated = true;
+          attrs.stderr_bytes_original = stderrOut.originalBytes;
+        }
+        updateAttrs = JSON.stringify(attrs);
+      }
+      if (updateAttrs) {
+        db.prepare(`
+          UPDATE spans
+          SET status = 'error',
+              error = ?,
+              attributes = ?,
+              completed_at = ?,
+              duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+          WHERE id = ?
+        `).run(error, updateAttrs, completedAt, completedAt, spanId);
+      } else {
+        db.prepare(`
+          UPDATE spans
+          SET status = 'error',
+              error = ?,
+              completed_at = ?,
+              duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+          WHERE id = ?
+        `).run(error, completedAt, completedAt, spanId);
+      }
       db.close();
     },
     _skipped: false
@@ -418,15 +568,33 @@ async function run(skillName, fn, options = {}) {
   const command = process.argv.slice(2).join(' ');
   const t = trace(skillName, command, options);
 
+  if (!t || t._skipped) {
+    return fn();
+  }
+
+  const origWrite = process.stdout.write.bind(process.stdout);
+  const chunks = [];
+  process.stdout.write = function (chunk, encoding, cb) {
+    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk));
+    if (typeof encoding === 'function') { return origWrite(chunk, encoding); }
+    return origWrite(chunk, encoding, cb);
+  };
+
   try {
     const result = await fn();
-    const resultStr = result !== undefined ? JSON.stringify(result) : null;
-    t.ok(resultStr);
+    process.stdout.write = origWrite;
+    if (result !== undefined) {
+      t.ok(JSON.stringify(result));
+    } else {
+      const output = Buffer.concat(chunks).toString('utf-8');
+      t.ok(output || null);
+    }
     return result;
   } catch (e) {
+    process.stdout.write = origWrite;
     t.fail(e.message || String(e));
     throw e;
   }
 }
 
-module.exports = { trace, run, getDbPath, getTracesDbPath };
+module.exports = { trace, run, getDbPath, getTracesDbPath, getOwnSkillVersion };

package/__tests__/skill-tracer.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import path from 'path';
-import fs from 'fs';
-
-describe('shared/skill-tracer', () => {
-  const sharedDir = path.resolve(__dirname, '..');
-
-  it('should be requireable from shared package', () => {
-    const tracer = require(path.join(sharedDir, 'skill-tracer.js'));
-    expect(tracer).toBeDefined();
-    expect(typeof tracer.trace).toBe('function');
-    expect(typeof tracer.run).toBe('function');
-    expect(typeof tracer.getDbPath).toBe('function');
-    expect(typeof tracer.getTracesDbPath).toBe('function');
-  });
-
-  it('should have package.json with correct name', () => {
-    const pkg = JSON.parse(fs.readFileSync(path.join(sharedDir, 'package.json'), 'utf-8'));
-    expect(pkg.name).toBe('@crewx/shared');
-    expect(pkg.main).toBe('skill-tracer.js');
-  });
-
-  it('re-export wrapper at skills/lib should work', () => {
-    const wrapperPath = path.resolve(__dirname, '../../../../skills/lib/skill-tracer.js');
-    const tracer = require(wrapperPath);
-    expect(tracer).toBeDefined();
-    expect(typeof tracer.trace).toBe('function');
-    expect(typeof tracer.run).toBe('function');
-  });
-
-  it('getDbPath should default to ~/.crewx/crewx.db', () => {
-    const tracer = require(path.join(sharedDir, 'skill-tracer.js'));
-    const dbPath = tracer.getDbPath();
-    expect(dbPath).toContain('.crewx');
-    expect(dbPath).toContain('crewx.db');
-  });
-});