Skip to content

ethanplusai/codex-on-crack / plugins/codex-on-crack/skills/crack

Lead substantial Codex builds with one configured implementation worker and lead acceptance. Use when the user requests codex-on-crack, names a model to delegate work to, asks to run subagents through Claude, or requests a lead/worker split. Keep host-only work direct; honor explicit external model choices. Workers must not invoke this orchestrator.

FileKindSize
SKILL.mdskill md8.0 KB
agents/openai.yamlconfig300 B
references/build-records.mdmarkdown2.7 KB
references/checkpoint.mdmarkdown1.3 KB
references/external-lead.mdmarkdown13.9 KB
references/measurement.mdmarkdown1.8 KB
references/model-selection.mdmarkdown2.2 KB
references/parallel.mdmarkdown1.7 KB
references/policy.mdmarkdown494 B
references/replay.mdmarkdown3.2 KB
references/verification.mdmarkdown2.1 KB
references/worker-contract.mdmarkdown1.3 KB
scripts/doctor.mjsscript608 B
scripts/lead.mjsscript26.0 KB
scripts/lib/catalog.mjsscript5.6 KB
scripts/lib/changes.mjsscript13.3 KB
scripts/lib/config.mjsscript6.5 KB
scripts/lib/external-lead.mjsscript56.7 KB
scripts/lib/io.mjsscript3.8 KB
scripts/lib/lead-protocol.mjsscript25.9 KB
scripts/lib/plan.mjsscript9.2 KB
scripts/lib/readiness.mjsscript6.0 KB
scripts/lib/report.mjsscript10.7 KB
scripts/lib/roles.mjsscript8.9 KB
scripts/lib/routing.mjsscript2.7 KB
scripts/lib/toml.mjsscript785 B
scripts/lib/trial.mjsscript12.4 KB
scripts/report.mjsscript2.7 KB
scripts/select.mjsscript3.9 KB
scripts/setup.mjsscript7.0 KB
scripts/trial.mjsscript1.8 KB
scripts/validate-plan.mjsscript2.6 KB
scripts/worktree.mjsscript7.8 KB
templates/checkpoint.mdmarkdown903 B
templates/plan.jsonconfig680 B
templates/spec.mdmarkdown742 B
templates/task-brief.mdmarkdown2.5 KB
templates/task-report.mdmarkdown1.5 KB
viewer/README.mdmarkdown5.9 KB
viewer/bridge.mjsscript16.6 KB
viewer/fixtures/sample.jsonconfig8.2 KB
viewer/package.jsonmanifest187 B
viewer/public/app.mjsscript8.8 KB
viewer/public/index.htmlother1.8 KB
viewer/public/style.cssother4.4 KB
viewer/serve.mjsscript11.2 KB
viewer/src/adapter.mjsscript9.9 KB
viewer/src/emit.mjsscript992 B
viewer/src/model.mjsscript8.9 KB
viewer/src/server.mjsscript4.1 KB
viewer/src/tail.mjsscript1.9 KB
viewer/test/browser.mjsscript2.6 KB
viewer/test/server.test.mjsscript3.2 KB
viewer/test/usage.test.mjsscript9.0 KB
viewer/test/viewer.test.mjsscript5.1 KB

scripts/lib/io.mjs

View on GitHub
// Shared I/O for codex-on-crack scripts: JSON results, atomic writes, hashing.
import { createHash, randomBytes } from 'node:crypto';
import fs from 'node:fs';
import path from 'node:path';

export class CrackError extends Error {
  constructor(code, message, hint = null) {
    super(message);
    this.code = code;
    this.hint = hint;
  }
}

export function sha256(data) {
  return data == null ? null : createHash('sha256').update(data).digest('hex');
}

// Refuse a path when it, or any ancestor, is a symlink. Roots come from
// locations(), which resolves them, so a symlink found here was planted inside
// the tree we are about to read or write.
export function refuseSymlinks(target) {
  let current = path.resolve(target);
  for (;;) {
    let stat = null;
    try {
      stat = fs.lstatSync(current);
    } catch (error) {
      if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error;
    }
    if (stat?.isSymbolicLink()) {
      throw new CrackError('symlink_refused', `Refusing to use a path through a symlink: ${current}`,
        'Replace the symlink with a real directory or file, then retry.');
    }
    const parent = path.dirname(current);
    if (parent === current) return;
    current = parent;
  }
}

export function readIfExists(file) {
  refuseSymlinks(file);
  let stat;
  try {
    stat = fs.statSync(file);
  } catch (error) {
    // ENOTDIR: an ancestor is a regular file, so this file cannot exist.
    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return null;
    throw error;
  }
  if (!stat.isFile()) {
    throw new CrackError('not_a_file', `Expected a regular file: ${file}`, 'Move whatever is at that path aside, then retry.');
  }
  return fs.readFileSync(file);
}

// The real path of a file the user pointed at. When it does not exist yet,
// resolve its nearest existing ancestor instead. macOS links /tmp and /var into
// /private, so user inputs routinely sit under a symlink.
export function realInput(file) {
  const resolved = path.resolve(file);
  try {
    return fs.realpathSync(resolved);
  } catch (error) {
    if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error;
    const parent = path.dirname(resolved);
    return parent === resolved ? resolved : path.join(realInput(parent), path.basename(resolved));
  }
}

// Read a file the user chose (a draft, a plan, a log). Unlike readIfExists,
// which guards the trees we write into, this follows symlinks to the real file.
export function readInput(file) {
  return readIfExists(realInput(file));
}

export function atomicWrite(file, data, mode = 0o600) {
  refuseSymlinks(file);
  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
  const temp = path.join(path.dirname(file), `.crack-${randomBytes(6).toString('hex')}`);
  try {
    const fd = fs.openSync(temp, 'wx', mode);
    try {
      fs.writeFileSync(fd, data);
      fs.fsyncSync(fd);
    } finally {
      fs.closeSync(fd);
    }
    fs.chmodSync(temp, mode);
    fs.renameSync(temp, file);
  } finally {
    fs.rmSync(temp, { force: true });
  }
}

export function ok(fields = {}) {
  return { ok: true, ...fields };
}

export function failure(error) {
  if (error instanceof CrackError) {
    return { ok: false, error: error.code, message: error.message, hint: error.hint };
  }
  // An unexpected error's message can quote file contents; never echo it.
  return {
    ok: false,
    error: 'internal_error',
    message: `Unexpected ${error?.name ?? 'error'}; no further detail is reported.`,
    hint: 'Re-run the same command. If it repeats, inspect locally.',
  };
}

export async function run(main) {
  let result;
  try {
    result = await main(process.argv.slice(2));
  } catch (error) {
    result = failure(error);
  }
  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
  process.exitCode = result.ok ? 0 : 2;
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexUnverifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall