Is Archify safe?
- Node.js shell/command execution
- Node.js filesystem read
- Node.js filesystem write/delete
repo is an AI directory analyzed by SkillTotal's deterministic static scanner. The scan found no malicious indicators, though 4 risky constructs are reported for review. It can: filesystem read, filesystem write, network egress and shell execution — capabilities are what the code can do, not a verdict on intent. Risk score 0/100 (low).
repo
Automated static-analysis result. It can contain false positives and false negatives, and is not a claim about the intent of Archify's authors. Report a false positive.
Behavioral traits
How this component maps to the CSA agentic threat model. Descriptive — it never affects the risk score.
Findings (4)
The component can run operating-system commands or spawn processes.
import { spawnSync } from 'node:child_process';return spawnSync(process.execPath, args, {import { spawnSync } from 'node:child_process';result = spawn(opener.command, opener.args(target), {import { spawn } from 'node:child_process';child = spawn(process.execPath, args, {import { spawn } from 'node:child_process';this.child = spawn(chromePath, args, { stdio: ['ignore', 'ignore', 'pipe', 'pipe', 'pipe'] });while ((open = opener.exec(svg))) {while ((tag = tags.exec(svg))) {import { spawnSync } from 'node:child_process';const result = spawnSync('git', ['-C', repoRoot, ...args], {import { execFileSync } from 'node:child_process';Why it matters: Powerful and often legitimate — confirm the commands aren't built from untrusted input.
Fix: Confirm the command and its arguments are fully controlled and not derived from untrusted input; prefer execFile with an argument array.
The component reads files from disk.
const artifact = fs.readFileSync(outputPath);
baseBuffer = fs.readFileSync(basePath);
headBuffer = fs.readFileSync(headPath);
const artifact = fs.readFileSync(htmlCandidate);
specification = fs.readFileSync(inputPath);
artifact = fs.readFileSync(candidatePath);
const engineeringProfile = engineeringProfileFromArtifact(fs.readFileSync(out));
const bytes = fs.readFileSync(inputPath);
const source = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
candidate = fs.readFileSync(candidatePath);
try { outputMatches = sha256(fs.readFileSync(outputPath)) === digest; } catch {}const artifactBytes = fs.readFileSync(artifact);
const afterBytes = fs.readFileSync(artifact);
const diagram = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
const template = fs.readFileSync(path.join(skillRoot, 'assets/template.html'), 'utf8');
html = fs.readFileSync(htmlPath, 'utf8');
ajv.addSchema(JSON.parse(fs.readFileSync(path.join(schemasDir, 'common.schema.json'), 'utf8')));
const schema = JSON.parse(fs.readFileSync(path.join(schemasDir, `${type}.schema.json`), 'utf8'));? fs.readFileSync(output, 'utf8').replace(/\r\n?/g, '\n')
Why it matters: Usually legitimate, but worth confirming it can't be steered into reading sensitive files.
Fix: Confirm which files are read and that paths cannot be influenced by untrusted input to reach sensitive locations.
The component writes or deletes files on disk.
fs.rmSync(item.target, { force: true });if (fs.existsSync(item.target)) fs.rmSync(item.target, { force: true });fs.writeFileSync(canonicalBaseInput, JSON.stringify(canonicalArchitecture(base)));
fs.writeFileSync(canonicalHeadInput, JSON.stringify(canonicalArchitecture(head)));
fs.writeFileSync(htmlCandidate, html);
fs.writeFileSync(receiptCandidate, `${JSON.stringify(finalReceipt, null, 2)}\n`);fs.rmSync(stagingDirectory, { recursive: true, force: true });fs.writeFileSync(specificationSnapshotPath, specification, { flag: 'wx' });fs.rmSync(stagingDirectory, { recursive: true, force: true });fs.rmSync(tmp, { recursive: true, force: true });fs.rmSync(stagingDirectory, { recursive: true, force: true });fs.rmSync(stagingDirectory, { recursive: true, force: true });fs.writeFileSync(snapshotPath, digest.bytes, { flag: 'wx', mode: 0o600 });try { fs.rmSync(candidatePath, { force: true }); } catch {}try { fs.rmSync(snapshotPath, { force: true }); } catch {}fs.rmSync(file, { force: true });fs.writeFileSync(temporary, contents, { flag: 'w' });fs.writeFileSync(screenshotPath, Buffer.from(capture.data, 'base64'));
fs.rmSync(this.profileRoot, { recursive: true, force: true });fs.writeFileSync(outPath, applyTemplate(template, {fs.unlinkSync(authoredPath);
fs.writeFileSync(temporary, generated);
Why it matters: Usually legitimate, but worth confirming the paths can't be controlled by untrusted input.
Fix: Confirm which files are written/deleted and that paths cannot be influenced by untrusted input.
The component makes outbound network requests.
import http from 'node:http';
Why it matters: Usually legitimate, but confirm the destinations are expected and no sensitive data leaves.
Fix: Confirm the destination hosts are expected and that no sensitive data is sent off-host.
Check your own component
Run the same evidence-backed scan on any MCP server, agent skill, or package.
Scan your own componentHow we determine this: deterministic static analysis (regex + AST), evidence-anchored, no code execution. Methodology →