npm - cc-flight - Versions diffs - 0.4.1 - Mend

cc-flight 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/README.md +236 -0
package/README.zh-CN.md +236 -0
package/core/contextReplay.ts +388 -0
package/core/cost.ts +129 -0
package/core/hash.ts +5 -0
package/core/history.ts +96 -0
package/core/id.ts +6 -0
package/core/normalizer.ts +720 -0
package/core/parser.ts +53 -0
package/core/redactor.ts +49 -0
package/core/replay.ts +55 -0
package/core/timeline.ts +350 -0
package/core/types.ts +460 -0
package/dist/ui/assets/index-Cu10rtbj.css +1 -0
package/dist/ui/assets/index-D572SQ_N.js +32 -0
package/dist/ui/favicon.svg +5 -0
package/dist/ui/index.html +14 -0
package/package.json +76 -0
package/runtime-node/adapters/claude-code.ts +215 -0
package/runtime-node/adapters/codex.ts +24 -0
package/runtime-node/adapters/index.ts +18 -0
package/runtime-node/adapters/opencode.ts +275 -0
package/runtime-node/adapters/shared.ts +113 -0
package/runtime-node/chrome-devtools.ts +22 -0
package/runtime-node/cli-ingest.ts +7 -0
package/runtime-node/cli-start.js +15 -0
package/runtime-node/cli-start.ts +21 -0
package/runtime-node/dev-server.ts +13 -0
package/runtime-node/git-provider.ts +102 -0
package/runtime-node/history.ts +9 -0
package/runtime-node/ingest-worker.ts +32 -0
package/runtime-node/ingest.ts +368 -0
package/runtime-node/prod-server.ts +24 -0
package/runtime-node/scanner.ts +13 -0
package/runtime-node/server.ts +214 -0
package/storage/database.ts +1016 -0
package/storage/paths.ts +29 -0

package/dist/ui/favicon.svg ADDED Viewed

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="12" fill="#111827"/>
+  <path d="M15 19h34v6H15zM15 30h24v6H15zM15 41h34v6H15z" fill="#f8fafc"/>
+  <path d="M45 29l7 5-7 5z" fill="#38bdf8"/>
+</svg>

package/dist/ui/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en" data-theme="light">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
+  <title>SuperView</title>
+  <script type="module" crossorigin src="/assets/index-D572SQ_N.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-Cu10rtbj.css">
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,76 @@
+{
+  "name": "cc-flight",
+  "version": "0.4.1",
+  "description": "Flight recorder for Claude Code and coding agents — timeline dashboard with replayable agent-run drill-downs.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TheAceTeam/SuperView.git"
+  },
+  "keywords": [
+    "cc",
+    "claude",
+    "codex",
+    "claude-code",
+    "ai-agent",
+    "observability",
+    "llm-tracing",
+    "agent-dashboard",
+    "developer-tools"
+  ],
+  "bin": {
+    "cc-flight": "runtime-node/cli-start.js",
+    "ccflight": "runtime-node/cli-start.js"
+  },
+  "files": [
+    "runtime-node/",
+    "core/",
+    "storage/",
+    "dist/ui/"
+  ],
+  "scripts": {
+    "dev": "concurrently -k -n server,client -c orange,blue \"pnpm dev:server\" \"pnpm dev:client\"",
+    "dev:client": "vite --host 127.0.0.1 --port 5173",
+    "dev:server": "tsx watch runtime-node/dev-server.ts",
+    "start": "node runtime-node/cli-start.js",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview --host 127.0.0.1 --port 4173",
+    "test": "vitest run",
+    "test:e2e": "playwright test",
+    "typecheck": "tsc --noEmit",
+    "ingest": "tsx runtime-node/cli-ingest.ts",
+    "publish:dual": "node scripts/publish-dual-packages.mjs",
+    "publish:dual:live": "node scripts/publish-dual-packages.mjs --publish"
+  },
+  "dependencies": {
+    "@vitejs/plugin-react": "^5.1.1",
+    "better-sqlite3": "^12.11.1",
+    "chokidar": "^4.0.3",
+    "concurrently": "^9.2.1",
+    "date-fns": "^4.1.0",
+    "express": "^5.2.1",
+    "fast-glob": "^3.3.3",
+    "lucide-react": "^0.561.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tsx": "^4.21.0",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@types/supertest": "^7.2.0",
+    "jsdom": "^27.3.0",
+    "supertest": "^7.2.2",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16"
+  }
+}

package/runtime-node/adapters/claude-code.ts ADDED Viewed

@@ -0,0 +1,215 @@
+import fg from "fast-glob";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { AgentLogAdapter, NormalizedBundle, ParsedAgentEvent, TokenUsage } from "../../core/types";
+import { normalizeCodexLines } from "../../core/normalizer";
+import { resolveClaudeHome } from "../../storage/paths";
+import { asRecord, fileSource, makeTokenUsage, parsedEvent, stringValue } from "./shared";
+export const claudeCodeAdapter: AgentLogAdapter = {
+  provider: "claude-code",
+  async scan(config) {
+    const root = config?.root ?? resolveClaudeHome();
+    const projectsDir = path.join(root, "projects");
+    const files = await fg("**/*.jsonl", {
+      cwd: projectsDir,
+      absolute: true,
+      onlyFiles: true,
+      suppressErrors: true
+    });
+    return Promise.all(files.map((file) => fileSource("claude-code", file)));
+  },
+  async parseSource(source, options = {}) {
+    const content = await readFile(source.path, "utf8");
+    const externalSessionId = externalSessionIdFromClaudeJsonl(content, source.path);
+    const historyProject = externalSessionId ? await claudeHistoryProjectForSession(source.path, externalSessionId) : null;
+    return normalizeClaudeCodeJsonl(content, source.path, options.repoRoot, historyProject);
+  }
+};
+export function normalizeClaudeCodeJsonl(content: string, sourcePath: string, repoRoot?: string | null, projectCwdOverride?: string | null): NormalizedBundle | null {
+  const rawLines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  const records = rawLines.map((line) => JSON.parse(line) as unknown);
+  if (records.length === 0) return null;
+  // Metadata fields aren't guaranteed on the first record — headless `claude -p`
+  // sessions open with a queue-operation that carries no cwd/version. Scan for
+  // the first record that actually has each field instead of assuming line 0.
+  const firstWith = (key: string): string | undefined => {
+    for (const recordValue of records) {
+      const value = stringValue(asRecord(recordValue)[key]);
+      if (value) return value;
+    }
+    return undefined;
+  };
+  const externalSessionId = firstWith("sessionId") ?? path.basename(sourcePath, ".jsonl");
+  const startedAt = firstWith("timestamp") ?? new Date(0).toISOString();
+  const cwd = projectCwdOverride ?? firstWith("cwd") ?? process.cwd();
+  const version = firstWith("version");
+  const lines: ParsedAgentEvent[] = [
+    parsedEvent({
+      provider: "claude-code",
+      sourcePath,
+      lineNo: 1,
+      timestamp: startedAt,
+      type: "session_meta",
+      payload: {
+        id: externalSessionId,
+        timestamp: startedAt,
+        cwd,
+        cli_version: version,
+        model_provider: "Anthropic",
+        source: "claude-code"
+      },
+      raw: rawLines[0]
+    })
+  ];
+  let syntheticLine = 2;
+  for (const [index, recordValue] of records.entries()) {
+    const record = asRecord(recordValue);
+    const timestamp = stringValue(record.timestamp) ?? startedAt;
+    const type = stringValue(record.type);
+    const message = asRecord(record.message);
+    const role = stringValue(message.role) ?? type;
+    const content = message.content;
+    const usage = makeTokenUsage(message.usage ?? record.usage);
+    for (const eventPayload of claudePayloadsForRecord(content, role, usage)) {
+      lines.push(
+        parsedEvent({
+          provider: "claude-code",
+          sourcePath,
+          lineNo: syntheticLine,
+          timestamp,
+          type: "response_item",
+          payload: eventPayload,
+          raw: rawLines[index]
+        })
+      );
+      syntheticLine += 1;
+    }
+  }
+  return normalizeCodexLines(lines, {
+    repoRoot,
+    provider: "claude-code",
+    prefixSessionId: true,
+    modelProvider: "Anthropic",
+    source: "claude-code",
+    agentName: "Claude Code"
+  });
+}
+function externalSessionIdFromClaudeJsonl(content: string, sourcePath: string): string | null {
+  const firstLine = content.split(/\r?\n/).find((line) => line.trim().length > 0);
+  if (!firstLine) return path.basename(sourcePath, ".jsonl");
+  try {
+    return stringValue(asRecord(JSON.parse(firstLine)).sessionId) ?? path.basename(sourcePath, ".jsonl");
+  } catch {
+    return path.basename(sourcePath, ".jsonl");
+  }
+}
+async function claudeHistoryProjectForSession(sourcePath: string, externalSessionId: string): Promise<string | null> {
+  const claudeRoot = claudeRootFromSourcePath(sourcePath);
+  if (!claudeRoot) return null;
+  try {
+    const history = await readFile(path.join(claudeRoot, "history.jsonl"), "utf8");
+    let project: string | null = null;
+    for (const line of history.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = asRecord(JSON.parse(line));
+        if (stringValue(record.sessionId) === externalSessionId) {
+          project = stringValue(record.project) ?? project;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return project;
+  } catch {
+    return null;
+  }
+}
+function claudeRootFromSourcePath(sourcePath: string): string | null {
+  const marker = `${path.sep}projects${path.sep}`;
+  const index = sourcePath.lastIndexOf(marker);
+  return index >= 0 ? sourcePath.slice(0, index) : null;
+}
+function claudePayloadsForRecord(content: unknown, role: string | null, usage: TokenUsage | null): Array<Record<string, unknown>> {
+  if (role === "user" && containsToolResult(content)) {
+    return toolResultsFromContent(content);
+  }
+  const payloads: Array<Record<string, unknown>> = [];
+  const text = textFromContent(content);
+  if (text) {
+    payloads.push({
+      type: "message",
+      role: role === "assistant" ? "assistant" : "user",
+      content: [{ type: role === "assistant" ? "output_text" : "input_text", text }],
+      ...(usage ? { usage } : {})
+    });
+  }
+  if (role === "assistant") {
+    payloads.push(...toolCallsFromContent(content));
+  }
+  return payloads;
+}
+function containsToolResult(content: unknown): boolean {
+  return contentItems(content).some((item) => stringValue(asRecord(item).type) === "tool_result");
+}
+function toolResultsFromContent(content: unknown): Array<Record<string, unknown>> {
+  return contentItems(content)
+    .filter((item) => stringValue(asRecord(item).type) === "tool_result")
+    .map((item) => {
+      const record = asRecord(item);
+      return {
+        type: "function_call_output",
+        call_id: stringValue(record.tool_use_id) ?? stringValue(record.id),
+        output: textFromContent(record.content)
+      };
+    });
+}
+function toolCallsFromContent(content: unknown): Array<Record<string, unknown>> {
+  return contentItems(content)
+    .filter((item) => stringValue(asRecord(item).type) === "tool_use")
+    .map((item) => {
+      const record = asRecord(item);
+      return {
+        type: "function_call",
+        call_id: stringValue(record.id),
+        name: stringValue(record.name) ?? "tool",
+        arguments: JSON.stringify(record.input ?? {})
+      };
+    });
+}
+function textFromContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  return contentItems(content)
+    .map((item) => {
+      if (typeof item === "string") return item;
+      const record = asRecord(item);
+      const type = stringValue(record.type);
+      if (type === "text") return stringValue(record.text) ?? "";
+      if (type === "tool_result") return textFromContent(record.content);
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+function contentItems(content: unknown): unknown[] {
+  if (Array.isArray(content)) return content;
+  if (content === null || content === undefined) return [];
+  return [content];
+}

package/runtime-node/adapters/codex.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { AgentLogAdapter } from "../../core/types";
+import { parseCodexJsonlFile } from "../../core/parser";
+import { normalizeCodexLines } from "../../core/normalizer";
+import { resolveCodexHome } from "../../storage/paths";
+import { scanRolloutFiles } from "../scanner";
+import { fileSource } from "./shared";
+export const codexAdapter: AgentLogAdapter = {
+  provider: "codex",
+  async scan(config) {
+    const files = await scanRolloutFiles(config?.root ?? resolveCodexHome());
+    return Promise.all(files.map((file) => fileSource("codex", file)));
+  },
+  async parseSource(source, options = {}) {
+    const lines = await parseCodexJsonlFile(source.path);
+    return normalizeCodexLines(lines, {
+      repoRoot: options.repoRoot,
+      provider: "codex",
+      prefixSessionId: true,
+      modelProvider: "OpenAI",
+      source: "codex"
+    });
+  }
+};

package/runtime-node/adapters/index.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { AgentLogAdapter, AgentProvider } from "../../core/types";
+import { claudeCodeAdapter } from "./claude-code";
+import { codexAdapter } from "./codex";
+import { opencodeAdapter } from "./opencode";
+const adapters: Record<AgentProvider, AgentLogAdapter> = {
+  codex: codexAdapter,
+  "claude-code": claudeCodeAdapter,
+  opencode: opencodeAdapter
+};
+export function adapterForProvider(provider: AgentProvider): AgentLogAdapter {
+  return adapters[provider];
+}
+export function defaultAdapters(): AgentLogAdapter[] {
+  return [codexAdapter];
+}

package/runtime-node/adapters/opencode.ts ADDED Viewed

@@ -0,0 +1,275 @@
+import { existsSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { AgentLogAdapter, AgentLogSource, NormalizedBundle, ParsedAgentEvent } from "../../core/types";
+import { normalizeCodexLines } from "../../core/normalizer";
+import { opencodeDbCandidates } from "../../storage/paths";
+import { asRecord, makeTokenUsage, numberTimestamp, parsedEvent, readJsonFile, stringValue } from "./shared";
+const SOURCE_PREFIX = "opencode:ses:";
+export const opencodeAdapter: AgentLogAdapter = {
+  provider: "opencode",
+  async scan(config) {
+    if (config?.path) {
+      return [await fileLikeSource(config.path)];
+    }
+    const dbPath = resolveOpencodeDb();
+    if (!dbPath) return [];
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const rows = db
+        .prepare(
+          "SELECT s.id AS id, s.time_updated AS timeUpdated, COUNT(p.id) AS parts " +
+            "FROM session s LEFT JOIN part p ON p.session_id = s.id GROUP BY s.id"
+        )
+        .all() as Array<{ id: string; timeUpdated: number; parts: number }>;
+      return rows.map((row) => ({
+        provider: "opencode" as const,
+        id: `${SOURCE_PREFIX}${row.id}`,
+        path: dbPath,
+        sizeBytes: row.parts,
+        mtimeMs: row.timeUpdated
+      }));
+    } finally {
+      db.close();
+    }
+  },
+  async parseSource(source, options = {}) {
+    if (!source.id.startsWith(SOURCE_PREFIX)) {
+      const json = await readJsonFile(source.path);
+      return normalizeOpenCodeExport(json, source.path, options.repoRoot);
+    }
+    const sessionId = source.id.slice(SOURCE_PREFIX.length);
+    const db = new Database(source.path, { readonly: true, fileMustExist: true });
+    try {
+      const session = db.prepare("SELECT * FROM session WHERE id = ?").get(sessionId) as
+        | Record<string, unknown>
+        | undefined;
+      if (!session) return null;
+      const messageRows = db
+        .prepare("SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created")
+        .all(sessionId) as Array<{ id: string; data: string }>;
+      const partRows = db
+        .prepare("SELECT message_id AS messageId, data FROM part WHERE session_id = ? ORDER BY time_created")
+        .all(sessionId) as Array<{ messageId: string; data: string }>;
+      const partsByMessage = new Map<string, unknown[]>();
+      for (const part of partRows) {
+        const list = partsByMessage.get(part.messageId) ?? [];
+        list.push(safeParse(part.data));
+        partsByMessage.set(part.messageId, list);
+      }
+      const exportShape = {
+        info: {
+          id: session.id,
+          directory: session.directory,
+          version: session.version,
+          title: session.title,
+          time: { created: session.time_created, updated: session.time_updated }
+        },
+        messages: messageRows.map((message) => ({
+          info: safeParse(message.data),
+          parts: partsByMessage.get(message.id) ?? []
+        }))
+      };
+      return normalizeOpenCodeExport(exportShape, source.path, options.repoRoot);
+    } finally {
+      db.close();
+    }
+  }
+};
+export function normalizeOpenCodeExport(json: unknown, sourcePath: string, repoRoot?: string | null): NormalizedBundle | null {
+  const root = asRecord(json);
+  const info = asRecord(root.info ?? root);
+  const messages = asArray(root.messages ?? root.message ?? root.parts);
+  const externalSessionId = stringValue(info.id) ?? stringValue(root.id) ?? path.basename(sourcePath, ".json");
+  const cwd = stringValue(info.directory) ?? stringValue(info.cwd) ?? stringValue(root.cwd) ?? process.cwd();
+  const startedAt = timestampFromValue(asRecord(info.time).created ?? info.created ?? messages[0]);
+  const version = stringValue(info.version) ?? stringValue(root.version);
+  const modelProvider = providerFromMessages(messages) ?? stringValue(info.provider);
+  const lines: ParsedAgentEvent[] = [
+    parsedEvent({
+      provider: "opencode",
+      sourcePath,
+      lineNo: 1,
+      timestamp: startedAt,
+      type: "session_meta",
+      payload: {
+        id: externalSessionId,
+        timestamp: startedAt,
+        cwd,
+        cli_version: version,
+        model_provider: modelProvider,
+        source: "opencode"
+      }
+    })
+  ];
+  let lineNo = 2;
+  for (const messageValue of messages) {
+    const message = asRecord(messageValue);
+    const mi = asRecord(message.info ?? message);
+    const timestamp = timestampFromValue(asRecord(mi.time).created ?? mi.created ?? mi.timestamp);
+    const role = stringValue(mi.role) ?? stringValue(mi.type);
+    const parts = asArray(message.parts ?? mi.parts ?? message.content);
+    const usage = makeTokenUsage(mi.tokens ?? mi.usage);
+    const messageText = textFromParts(parts);
+    if ((role === "user" || role === "assistant") && messageText) {
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "message",
+            role,
+            content: [{ type: role === "assistant" ? "output_text" : "input_text", text: messageText }],
+            ...(usage ? { usage } : {})
+          }
+        })
+      );
+      lineNo += 1;
+    }
+    for (const part of parts) {
+      const partRecord = asRecord(part);
+      if (!isToolPart(partRecord)) continue;
+      const state = asRecord(partRecord.state);
+      const callId = stringValue(partRecord.callID) ?? stringValue(partRecord.callId) ?? stringValue(partRecord.id);
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "function_call",
+            call_id: callId,
+            name: stringValue(partRecord.tool) ?? stringValue(partRecord.name) ?? "tool",
+            arguments: JSON.stringify(state.input ?? partRecord.input ?? partRecord.arguments ?? {})
+          }
+        })
+      );
+      lineNo += 1;
+      const output = toolOutput(state);
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "function_call_output",
+            call_id: callId,
+            output
+          }
+        })
+      );
+      lineNo += 1;
+    }
+  }
+  return normalizeCodexLines(lines, {
+    repoRoot,
+    provider: "opencode",
+    prefixSessionId: true,
+    modelProvider,
+    source: "opencode",
+    agentName: "OpenCode"
+  });
+}
+function resolveOpencodeDb(): string | null {
+  for (const candidate of opencodeDbCandidates()) {
+    try {
+      if (existsSync(candidate)) return candidate;
+    } catch {
+      // ignore — try next candidate
+    }
+  }
+  return null;
+}
+async function fileLikeSource(filePath: string): Promise<AgentLogSource> {
+  const content = await readFile(filePath, "utf8");
+  const stats = statSync(filePath);
+  return {
+    provider: "opencode",
+    id: `opencode:${filePath}`,
+    path: filePath,
+    sizeBytes: Buffer.byteLength(content),
+    mtimeMs: stats.mtimeMs
+  };
+}
+function safeParse(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+function asArray(value: unknown): unknown[] {
+  if (Array.isArray(value)) return value;
+  if (!value || typeof value !== "object") return [];
+  const record = value as Record<string, unknown>;
+  for (const key of ["items", "data", "sessions", "messages"]) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+function timestampFromValue(value: unknown): string {
+  if (typeof value === "string") return value;
+  const numeric = numberTimestamp(value);
+  return numeric ?? new Date(0).toISOString();
+}
+function providerFromMessages(messages: unknown[]): string | null {
+  for (const messageValue of messages) {
+    const mi = asRecord(asRecord(messageValue).info ?? messageValue);
+    const provider = stringValue(mi.providerID) ?? stringValue(mi.provider);
+    if (provider) return provider;
+  }
+  return null;
+}
+function textFromParts(value: unknown): string {
+  if (typeof value === "string") return value;
+  return asArray(value)
+    .map((part) => {
+      if (typeof part === "string") return part;
+      const record = asRecord(part);
+      if (record.type && record.type !== "text") return "";
+      return stringValue(record.text) ?? stringValue(record.content) ?? stringValue(record.output) ?? "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+function isToolPart(part: Record<string, unknown>) {
+  const type = stringValue(part.type);
+  if (type === "tool" || type === "tool_call") return true;
+  if (type) return false;
+  return Boolean(part.tool ?? part.name);
+}
+function toolOutput(state: Record<string, unknown>): string {
+  const direct = stringValue(state.output);
+  if (direct) return direct;
+  const metaOutput = stringValue(asRecord(state.metadata).output);
+  if (metaOutput) return metaOutput;
+  return "";
+}