@iiwish/agentrecord 0.0.1

package/src/commands/open.mjs

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+import { loadConfig } from "../core/config.mjs";
+
+export async function runOpen({ options }) {
+  const config = loadConfig(options);
+  const htmlFile = path.join(config.resolved.profileDir, "index.html");
+
+  if (!fs.existsSync(htmlFile)) {
+    console.error(JSON.stringify({
+      ok: false,
+      file: htmlFile,
+      message: "index.html was not found. Run `agentrecord build` first, then retry `agentrecord open`."
+    }, null, 2));
+    process.exitCode = 1;
+    return;
+  }
+
+  const result = await openFile(htmlFile);
+  if (!result.ok) {
+    console.error(JSON.stringify({
+      ok: false,
+      file: htmlFile,
+      message: result.message,
+      fallback: "Open the file manually in a browser."
+    }, null, 2));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    file: htmlFile,
+    opener: result.opener
+  }, null, 2));
+}
+
+async function openFile(file) {
+  const candidates = openerCandidates(file);
+  const failures = [];
+
+  for (const candidate of candidates) {
+    const result = await spawnAndWait(candidate.command, candidate.args);
+    if (result.ok) return { ok: true, opener: candidate.command };
+    failures.push(`${candidate.command}: ${result.message}`);
+  }
+
+  return {
+    ok: false,
+    message: `No supported opener succeeded. ${failures.join(" | ")}`
+  };
+}
+
+function openerCandidates(file) {
+  if (process.platform === "darwin") return [{ command: "open", args: [file] }];
+  if (process.platform === "win32") return [{ command: "cmd", args: ["/c", "start", "", file] }];
+  return [
+    { command: "xdg-open", args: [file] },
+    { command: "gio", args: ["open", file] }
+  ];
+}
+
+function spawnAndWait(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      detached: false,
+      stdio: "ignore"
+    });
+
+    child.on("error", (error) => {
+      resolve({ ok: false, message: error.message });
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) resolve({ ok: true });
+      else resolve({ ok: false, message: `exited with code ${code}` });
+    });
+  });
+}

package/src/commands/scan.mjs

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { loadConfig } from "../core/config.mjs";
+
+export async function runScan({ options }) {
+  const config = loadConfig(options);
+  const sources = config.resolved.codex.sessionRoots.map((sessionRoot) => {
+    const exists = fs.existsSync(sessionRoot);
+    return {
+      client_id: "codex",
+      path: sessionRoot,
+      found: exists,
+      status: exists ? "available" : "missing",
+      rollout_files: exists ? countRolloutFiles(sessionRoot) : 0
+    };
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    config: {
+      path: config.configPath,
+      exists: config.exists,
+      owner: config.resolved.owner,
+      profile_dir: config.resolved.profileDir,
+      private_state_dir: config.resolved.privateStateDir,
+      locale: config.resolved.report.locale,
+      privacy: config.resolved.privacy
+    },
+    sources
+  }, null, 2));
+}
+
+function countRolloutFiles(rootDir) {
+  let count = 0;
+  const stack = [rootDir];
+
+  while (stack.length) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(target);
+      } else if (entry.isFile() && /^rollout-.*\.jsonl$/.test(entry.name)) {
+        count += 1;
+      }
+    }
+  }
+
+  return count;
+}

package/src/commands/validate.mjs

@@ -0,0 +1,365 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { loadConfig, readJsonIfExists } from "../core/config.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..");
+
+const requiredArtifacts = [
+  "profile.json",
+  "evidence.jsonl",
+  "index.html",
+  "profile.md",
+  "redaction-report.md",
+  "run-report.md"
+];
+
+const optionalPublicArtifacts = [
+  "agent-context.md",
+  "agent-context.json"
+];
+
+export async function runValidate({ options }) {
+  const config = loadConfig(options);
+  const errors = [];
+  const profileDir = config.resolved.profileDir;
+  const stateFile = path.join(config.resolved.privateStateDir, "state.json");
+
+  const profile = readRequiredJson(path.join(profileDir, "profile.json"), errors, "required_artifact");
+  const evidence = readEvidenceJsonl(path.join(profileDir, "evidence.jsonl"), errors);
+
+  checkRequiredArtifacts(profileDir, errors);
+  if (profile) checkProfileStructure(profile, errors);
+  if (profile && evidence) checkEvidenceRefs(profile, evidence, config, errors);
+  checkLocaleParity(errors);
+  checkPrivateState(stateFile, profile, errors);
+  checkPublicArtifactPrivacy(profileDir, profile, errors);
+
+  if (errors.length) {
+    console.error(JSON.stringify({
+      ok: false,
+      profile_dir: profileDir,
+      error_count: errors.length,
+      errors
+    }, null, 2));
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    profile_dir: profileDir,
+    required_artifacts: requiredArtifacts.length,
+    evidence_cards: evidence.length,
+    locale: profile.report.locale,
+    private_state: "present",
+    privacy_scan: "pass"
+  }, null, 2));
+}
+
+function addError(errors, file, rule, message) {
+  errors.push({ file, rule, message });
+}
+
+function readRequiredJson(file, errors, rule) {
+  if (!fs.existsSync(file)) {
+    addError(errors, file, rule, "File is missing.");
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    addError(errors, file, "valid_json", error.message);
+    return null;
+  }
+}
+
+function readEvidenceJsonl(file, errors) {
+  if (!fs.existsSync(file)) {
+    addError(errors, file, "required_artifact", "File is missing.");
+    return null;
+  }
+
+  const lines = fs.readFileSync(file, "utf8").split(/\n/).filter(Boolean);
+  const cards = [];
+  lines.forEach((line, index) => {
+    try {
+      cards.push(JSON.parse(line));
+    } catch (error) {
+      addError(errors, file, "valid_evidence_jsonl", `Line ${index + 1}: ${error.message}`);
+    }
+  });
+  return cards;
+}
+
+function checkRequiredArtifacts(profileDir, errors) {
+  for (const artifact of requiredArtifacts) {
+    const file = path.join(profileDir, artifact);
+    if (!fs.existsSync(file)) {
+      addError(errors, file, "required_artifact", "Required public artifact is missing.");
+      continue;
+    }
+    if (fs.statSync(file).size < 20) {
+      addError(errors, file, "required_artifact_size", "Required public artifact is unexpectedly small.");
+    }
+  }
+
+  for (const forbidden of ["hiring.html", "job-agent-profile.md"]) {
+    const file = path.join(profileDir, forbidden);
+    if (fs.existsSync(file)) {
+      addError(errors, file, "default_audience_boundary", "Hiring or job-agent artifact must not be generated by default.");
+    }
+  }
+}
+
+function checkProfileStructure(profile, errors) {
+  const file = "profile.json";
+  const requiredKeys = [
+    "schema_version",
+    "owner",
+    "generated_at",
+    "report",
+    "work_identity",
+    "work_role_signals",
+    "ability_model",
+    "agent_ledger",
+    "evidence_notes",
+    "calibration_notes",
+    "privacy_boundary",
+    "run_metadata"
+  ];
+
+  for (const key of requiredKeys) {
+    if (!Object.hasOwn(profile, key)) addError(errors, file, "profile_required_key", `Missing required key: ${key}`);
+  }
+
+  if (profile.schema_version !== "agentrecord.profile.v0") addError(errors, file, "profile_schema_version", "schema_version must be agentrecord.profile.v0.");
+  if (!profile.owner?.id || !profile.owner?.display_name) addError(errors, file, "profile_owner", "owner.id and owner.display_name are required.");
+  if (!["en-US", "zh-CN"].includes(profile.report?.locale)) addError(errors, file, "profile_locale", "report.locale must be en-US or zh-CN.");
+  if (profile.report?.schema_language !== "en-US") addError(errors, file, "profile_schema_language", "report.schema_language must remain en-US.");
+  const audiences = profile.report?.audiences;
+  const allowedAudiences = new Set(["self", "share"]);
+  if (!Array.isArray(audiences)) {
+    addError(errors, file, "profile_audiences", "report.audiences must be exactly self and share.");
+  } else {
+    const audienceSet = new Set(audiences);
+    for (const audience of audiences) {
+      if (!allowedAudiences.has(audience)) addError(errors, file, "profile_audiences", `report.audiences contains unsupported audience: ${audience}`);
+    }
+    if (audiences.length !== 2 || audienceSet.size !== 2 || !audienceSet.has("self") || !audienceSet.has("share")) {
+      addError(errors, file, "profile_audiences", "report.audiences must be exactly self and share.");
+    }
+  }
+  for (const forbidden of ["role_fit", "seniority_signal", "evidence_briefs", "agent_prompt_profile", "hiring_score", "candidate_score", "market_rank"]) {
+    if (Object.hasOwn(profile, forbidden)) addError(errors, file, "default_audience_boundary", `Default profile must not include ${forbidden}.`);
+  }
+  if (!profile.work_identity?.primary_label || !Array.isArray(profile.work_identity?.evidence_ids)) {
+    addError(errors, file, "work_identity", "work_identity must include primary_label and evidence_ids.");
+  }
+  if (!Array.isArray(profile.work_role_signals) || profile.work_role_signals.length < 5) {
+    addError(errors, file, "work_role_signals", "work_role_signals must contain at least 5 role signals.");
+  }
+  if (!Array.isArray(profile.ability_model) || profile.ability_model.length < 10) {
+    addError(errors, file, "ability_model", "ability_model must contain the v0.1 ability dimensions.");
+  }
+  if (!Array.isArray(profile.evidence_notes) || profile.evidence_notes.length < 1) {
+    addError(errors, file, "evidence_notes", "evidence_notes must contain at least one evidence note.");
+  }
+  if (!Array.isArray(profile.agent_ledger?.clients) || !profile.agent_ledger.clients.some((client) => client.client_id === "codex")) {
+    addError(errors, file, "agent_ledger", "agent_ledger.clients must include codex.");
+  }
+  if (profile.privacy_boundary?.raw_logs_included !== false) addError(errors, file, "privacy_boundary", "privacy_boundary.raw_logs_included must be false.");
+  if (profile.privacy_boundary?.public_session_ids_included !== false) addError(errors, file, "privacy_boundary", "privacy_boundary.public_session_ids_included must be false.");
+  if (profile.run_metadata?.public_session_ids_included !== false) addError(errors, file, "run_metadata", "run_metadata.public_session_ids_included must be false.");
+}
+
+function checkEvidenceRefs(profile, evidence, config, errors) {
+  const file = "evidence.jsonl";
+  const evidenceIds = new Set();
+
+  for (const card of evidence) {
+    if (!card.id || typeof card.id !== "string") addError(errors, file, "evidence_structure", "Evidence card missing id.");
+    evidenceIds.add(card.id);
+    if (!Array.isArray(card.level) || card.level.length === 0) addError(errors, file, "evidence_structure", `${card.id || "unknown"} missing level.`);
+    if (!card.title || !card.summary) addError(errors, file, "evidence_structure", `${card.id || "unknown"} missing title or summary.`);
+    if (!Array.isArray(card.refs)) addError(errors, file, "evidence_refs", `${card.id || "unknown"} refs must be an array.`);
+    if (card.privacy?.public_safe !== true) addError(errors, file, "evidence_privacy", `${card.id || "unknown"} must be marked public_safe.`);
+    for (const ref of card.refs || []) checkSingleEvidenceRef(ref, card.id, config, errors);
+  }
+
+  for (const note of profile.evidence_notes || []) {
+    if (!evidenceIds.has(note.evidence_id)) {
+      addError(errors, "profile.json", "evidence_reference", `profile evidence_notes references missing evidence id: ${note.evidence_id}`);
+    }
+    for (const ref of note.refs || []) checkSingleEvidenceRef(ref, note.evidence_id, config, errors);
+  }
+
+  for (const id of profile.work_identity?.evidence_ids || []) {
+    if (!evidenceIds.has(id)) addError(errors, "profile.json", "evidence_reference", `work_identity references missing evidence id: ${id}`);
+  }
+
+  for (const role of profile.work_role_signals || []) {
+    for (const id of role.evidence_ids || []) {
+      if (!evidenceIds.has(id)) addError(errors, "profile.json", "evidence_reference", `role ${role.role_id} references missing evidence id: ${id}`);
+    }
+  }
+
+  for (const ability of profile.ability_model || []) {
+    for (const id of ability.evidence_ids || []) {
+      if (!evidenceIds.has(id)) addError(errors, "profile.json", "evidence_reference", `ability ${ability.dimension_id} references missing evidence id: ${id}`);
+    }
+  }
+}
+
+function checkSingleEvidenceRef(ref, evidenceId, config, errors) {
+  if (!ref || typeof ref !== "object") {
+    addError(errors, "evidence.jsonl", "evidence_ref_parse", `${evidenceId} has a malformed ref.`);
+    return;
+  }
+
+  if (ref.type === "metadata" && ref.source === "codex_session_metadata") return;
+
+  if (ref.type === "memory") {
+    if (!ref.source || !Number.isInteger(ref.start_line) || !Number.isInteger(ref.end_line) || ref.start_line <= 0 || ref.end_line < ref.start_line) {
+      addError(errors, "evidence.jsonl", "evidence_ref_parse", `${evidenceId} has an invalid memory ref.`);
+      return;
+    }
+    const memoryPath = config.resolved.memory.registryPath;
+    if (!memoryPath || path.basename(memoryPath) !== ref.source || !fs.existsSync(memoryPath)) {
+      addError(errors, "evidence.jsonl", "evidence_ref_resolve", `${evidenceId} memory ref cannot resolve ${ref.source}.`);
+      return;
+    }
+    const lineCount = fs.readFileSync(memoryPath, "utf8").split(/\n/).length;
+    if (ref.end_line > lineCount) {
+      addError(errors, "evidence.jsonl", "evidence_ref_resolve", `${evidenceId} memory ref line range exceeds ${ref.source}.`);
+    }
+    return;
+  }
+
+  addError(errors, "evidence.jsonl", "evidence_ref_parse", `${evidenceId} has unsupported ref type: ${ref.type || "missing"}.`);
+}
+
+function checkLocaleParity(errors) {
+  const enFile = path.join(repoRoot, "locales", "en-US.json");
+  const zhFile = path.join(repoRoot, "locales", "zh-CN.json");
+  const en = readRequiredJson(enFile, errors, "locale_required");
+  const zh = readRequiredJson(zhFile, errors, "locale_required");
+  if (!en || !zh) return;
+
+  for (const namespace of ["ui", "roles", "abilities"]) {
+    const enKeys = new Set(collectKeys(en[namespace]).map((key) => `${namespace}.${key}`));
+    const zhKeys = new Set(collectKeys(zh[namespace]).map((key) => `${namespace}.${key}`));
+    for (const key of enKeys) {
+      if (!zhKeys.has(key)) addError(errors, zhFile, "locale_parity", `zh-CN missing key: ${key}`);
+    }
+    for (const key of zhKeys) {
+      if (!enKeys.has(key)) addError(errors, enFile, "locale_parity", `en-US missing key: ${key}`);
+    }
+  }
+}
+
+function collectKeys(value, prefix = "") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  return Object.entries(value).flatMap(([key, child]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    if (child && typeof child === "object" && !Array.isArray(child)) return [next, ...collectKeys(child, next)];
+    return [next];
+  });
+}
+
+function checkPrivateState(stateFile, profile, errors) {
+  const state = readRequiredJson(stateFile, errors, "private_state_required");
+  if (!state) return;
+  if (state.schema_version !== "agentrecord.state.v0") addError(errors, stateFile, "private_state_schema", "state schema_version must be agentrecord.state.v0.");
+  if (!Array.isArray(state.processed_session_ids)) addError(errors, stateFile, "private_state_sessions", "processed_session_ids must be an array.");
+  if (state.processed_session_ids?.length !== state.processed_sessions_count) {
+    addError(errors, stateFile, "private_state_sessions", "processed_session_ids length must match processed_sessions_count.");
+  }
+  if (!state.session_token_totals || typeof state.session_token_totals !== "object") {
+    addError(errors, stateFile, "private_state_tokens", "session_token_totals must exist.");
+  }
+  if (!state.last_profile_hash) addError(errors, stateFile, "private_state_hash", "last_profile_hash must exist.");
+  if (profile?.run_metadata?.private_state_present !== true) {
+    addError(errors, "profile.json", "private_state_public_marker", "run_metadata.private_state_present must be true.");
+  }
+}
+
+function checkPublicArtifactPrivacy(profileDir, profile, errors) {
+  const locale = profile?.report?.locale;
+  const publicArtifacts = [...requiredArtifacts, ...optionalPublicArtifacts].filter((artifact) => fs.existsSync(path.join(profileDir, artifact)));
+  for (const artifact of publicArtifacts) {
+    const file = path.join(profileDir, artifact);
+    const content = fs.readFileSync(file, "utf8");
+    for (const rule of privacyRules()) {
+      if (rule.pattern.test(content)) addError(errors, file, rule.id, rule.message);
+    }
+    const terminalIssue = detectTerminalOutput(content);
+    if (terminalIssue) addError(errors, file, "suspected_terminal_output", terminalIssue);
+    if (locale && artifact === "index.html" && !content.includes(`lang="${locale === "zh-CN" ? "zh-CN" : "en"}"`)) {
+      addError(errors, file, "html_locale", "index.html language attribute must match profile locale.");
+    }
+  }
+}
+
+function privacyRules() {
+  return [
+    {
+      id: "raw_uuid_session_like_id",
+      pattern: /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i,
+      message: "Public artifact contains a raw UUID/session-like id."
+    },
+    {
+      id: "codex_session_path",
+      pattern: /\/\.codex\/sessions\//,
+      message: "Public artifact contains a raw Codex session path."
+    },
+    {
+      id: "raw_user_role",
+      pattern: /"role"\s*:\s*"user"/,
+      message: "Public artifact contains raw user-message role payload."
+    },
+    {
+      id: "raw_input_payload",
+      pattern: /\binput_text\b/,
+      message: "Public artifact contains raw input payload marker."
+    },
+    {
+      id: "openai_secret_prefix",
+      pattern: /\bsk-[A-Za-z0-9_-]{8,}/,
+      message: "Public artifact contains an OpenAI secret-like prefix."
+    },
+    {
+      id: "github_token_prefix",
+      pattern: /\bghp_[A-Za-z0-9_]{8,}/,
+      message: "Public artifact contains a GitHub token-like prefix."
+    },
+    {
+      id: "private_key",
+      pattern: /BEGIN PRIVATE KEY/,
+      message: "Public artifact contains a private key marker."
+    },
+    {
+      id: "private_state_path",
+      pattern: /\/\.agentrecord\/|\.agentrecord\/state\.json/,
+      message: "Public artifact exposes private state path."
+    }
+  ];
+}
+
+function detectTerminalOutput(content) {
+  const lines = content.split(/\n/);
+  const codexOutputMarkers = [
+    /^Chunk ID:/m,
+    /^Wall time:/m,
+    /^Process exited with code/m,
+    /^Original token count:/m,
+    /^Output:/m
+  ].filter((pattern) => pattern.test(content)).length;
+  if (codexOutputMarkers >= 2) return "Public artifact appears to contain copied command output.";
+
+  const shellPromptLines = lines.filter((line) => /^\s*(\$|>|%)\s+\S+/.test(line) || /^\s*[A-Za-z0-9_.-]+@[A-Za-z0-9_.-]+.*[$#]\s+\S+/.test(line)).length;
+  if (shellPromptLines >= 10) return "Public artifact contains many shell-prompt-like lines.";
+  return null;
+}

package/src/core/args.mjs

@@ -0,0 +1,60 @@
+export function parseArgs(argv) {
+  const options = {};
+  const positional = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === "--") {
+      positional.push(...argv.slice(index + 1));
+      break;
+    }
+
+    if (!arg.startsWith("-") || arg === "-") {
+      positional.push(arg);
+      continue;
+    }
+
+    if (arg.startsWith("--no-")) {
+      options[toCamelCase(arg.slice(5))] = false;
+      continue;
+    }
+
+    if (arg.startsWith("--")) {
+      const raw = arg.slice(2);
+      const equalsIndex = raw.indexOf("=");
+      if (equalsIndex !== -1) {
+        options[toCamelCase(raw.slice(0, equalsIndex))] = raw.slice(equalsIndex + 1);
+        continue;
+      }
+
+      const name = toCamelCase(raw);
+      const next = argv[index + 1];
+      if (next && !next.startsWith("-")) {
+        options[name] = next;
+        index += 1;
+      } else {
+        options[name] = true;
+      }
+      continue;
+    }
+
+    if (arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "-v") {
+      options.version = true;
+      continue;
+    }
+
+    positional.push(arg);
+  }
+
+  return { options, positional };
+}
+
+export function toCamelCase(value) {
+  return String(value || "").replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}