@yunhozz/arc 0.2.3 → 0.2.4

package/claude/skill/hooks/git-policy.json

@@ -1,208 +0,0 @@
-{
-  "schemaVersion": 1,
-  "globalValueOptions": [
-    "-C",
-    "--git-dir",
-    "--work-tree"
-  ],
-  "globalFlags": [
-    "--no-pager",
-    "-P",
-    "--literal-pathspecs"
-  ],
-  "commands": {
-    "status": {
-      "flags": [
-        "--short",
-        "-s",
-        "--branch",
-        "-b",
-        "--porcelain",
-        "--porcelain=v1",
-        "--porcelain=v2",
-        "--untracked-files=no",
-        "--untracked-files=all"
-      ],
-      "values": [],
-      "positionals": "any"
-    },
-    "diff": {
-      "flags": [
-        "--stat",
-        "--numstat",
-        "--shortstat",
-        "--name-only",
-        "--name-status",
-        "--oneline",
-        "--no-color",
-        "--color=never",
-        "--no-ext-diff",
-        "--no-textconv",
-        "--raw",
-        "--patch",
-        "-p",
-        "--summary",
-        "--exit-code",
-        "--quiet",
-        "--check",
-        "--cached",
-        "--staged",
-        "--relative",
-        "--no-index"
-      ],
-      "values": [],
-      "positionals": "any"
-    },
-    "log": {
-      "flags": [
-        "--stat",
-        "--numstat",
-        "--shortstat",
-        "--name-only",
-        "--name-status",
-        "--oneline",
-        "--no-color",
-        "--color=never",
-        "--no-ext-diff",
-        "--no-textconv",
-        "--raw",
-        "--patch",
-        "-p",
-        "--summary",
-        "--exit-code",
-        "--quiet",
-        "-<count>",
-        "--all",
-        "--decorate",
-        "--no-decorate",
-        "--graph"
-      ],
-      "values": [
-        "-n",
-        "--max-count",
-        "--format",
-        "--pretty"
-      ],
-      "positionals": "any"
-    },
-    "show": {
-      "flags": [
-        "--stat",
-        "--numstat",
-        "--shortstat",
-        "--name-only",
-        "--name-status",
-        "--oneline",
-        "--no-color",
-        "--color=never",
-        "--no-ext-diff",
-        "--no-textconv",
-        "--raw",
-        "--patch",
-        "-p",
-        "--summary",
-        "--exit-code",
-        "--quiet",
-        "--no-patch",
-        "-s"
-      ],
-      "values": [
-        "--format",
-        "--pretty"
-      ],
-      "positionals": "any"
-    },
-    "rev-parse": {
-      "flags": [
-        "--show-toplevel",
-        "--git-common-dir",
-        "--absolute-git-dir",
-        "--git-dir",
-        "--verify",
-        "--short",
-        "--is-inside-work-tree",
-        "--abbrev-ref",
-        "--path-format=absolute"
-      ],
-      "values": [],
-      "positionals": "any"
-    },
-    "ls-files": {
-      "flags": [
-        "--stage",
-        "-s",
-        "--cached",
-        "--others",
-        "--exclude-standard",
-        "--deleted",
-        "--modified"
-      ],
-      "values": [],
-      "positionals": "any"
-    },
-    "ls-tree": {
-      "flags": [
-        "-r",
-        "--name-only",
-        "-l"
-      ],
-      "values": [],
-      "positionals": "any"
-    },
-    "branch": {
-      "flags": [
-        "--list",
-        "--all",
-        "-a",
-        "--remotes",
-        "-r",
-        "--show-current",
-        "-v",
-        "-vv"
-      ],
-      "values": [],
-      "positionals": "list"
-    },
-    "config": {
-      "flags": [
-        "--get",
-        "--get-all",
-        "--get-regexp",
-        "--list",
-        "-l",
-        "--show-origin",
-        "--show-scope",
-        "--local",
-        "--global",
-        "--system"
-      ],
-      "values": [],
-      "positionals": "query"
-    },
-    "worktree list": {
-      "flags": [
-        "--porcelain",
-        "-z",
-        "-v"
-      ],
-      "values": [],
-      "positionals": "none"
-    },
-    "remote": {
-      "flags": [
-        "-v",
-        "--verbose"
-      ],
-      "values": [],
-      "positionals": "none"
-    },
-    "remote get-url": {
-      "flags": [
-        "--all",
-        "--push"
-      ],
-      "values": [],
-      "positionals": "any"
-    }
-  }
-}

package/claude/skill/hooks/role-git-guard.mjs

@@ -1,18 +0,0 @@
-import fs from 'node:fs';
-import {pathToFileURL} from 'node:url';
-
-import {validateGitPolicy,classifyGitCommand} from '../runtime/git-query.mjs';
-export {validateGitPolicy,classifyGitCommand};
-const deny=reason=>({allowed:false,reason});
-export function evaluateHookEvent(event,policy) {
-  const result=event?.hook_event_name!=='PreToolUse' ? deny('Invalid hook event') : event?.tool_name!=='Bash' ? deny('Missing Bash event') : classifyGitCommand(event?.tool_input?.command,policy);
-  return result.allowed?{}:{hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason:`ARC specialist Git guard: ${result.reason}. Return the operation to Orchestrator.`}};
-}
-export function runHook() {
-  let response;
-  try {const policy=validateGitPolicy(JSON.parse(fs.readFileSync(new URL('./git-policy.json',import.meta.url),'utf8')));response=evaluateHookEvent(JSON.parse(fs.readFileSync(0,'utf8')),policy);}
-  catch {response={hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason:'ARC specialist Git guard: invalid input or policy asset. Stop and report to Orchestrator.'}};}
-  process.stdout.write(JSON.stringify(response)+'\n');
-}
-
-if(process.argv[1] && pathToFileURL(process.argv[1]).href===import.meta.url)runHook();

package/claude/skill/hooks/runtime-gate.mjs

@@ -1,12 +0,0 @@
-import {runClaudeGate,renderClaudeDecision} from '../runtime/adapters/claude.mjs';
-/** Native installation must provide trusted context separately; stdin is only
- * the platform event. Missing provider denies and never trusts event assertions. */
-export async function main(input,context){
- try{return await runClaudeGate(JSON.parse(input),context);}catch{return renderClaudeDecision({decision:'deny',reason:'Malformed runtime hook event'});}
-}
-export async function runHook(){
- let input='';for await(const chunk of process.stdin)input+=chunk;
- process.stdout.write(JSON.stringify(await main(input))+'\n');
-}
-
-if(process.argv[1]&&import.meta.url===new URL(process.argv[1], 'file:').href)await runHook();

package/codex/skill/hooks/runtime-gate.mjs

@@ -1,10 +0,0 @@
-import {runCodexGate,renderCodexDecision} from '../runtime/adapters/codex.mjs';
-/** Native installation must provide trusted context separately; stdin is only
- * the platform event. Missing provider denies and never trusts event assertions. */
-export async function main(input,context){
- try{return await runCodexGate(JSON.parse(input),context);}catch{return renderCodexDecision({decision:'deny',reason:'Malformed runtime hook event'});}
-}
-if(import.meta.url===new URL(process.argv[1], 'file:').href){
- let input='';for await(const chunk of process.stdin)input+=chunk;
- process.stdout.write(JSON.stringify(await main(input))+'\n');
-}

package/lib/policy/claude-hook.mjs

@@ -1,80 +0,0 @@
-import path from 'node:path';
-import {pathToFileURL} from 'node:url';
-// Only this fixed bootstrap is executed. The separately encoded path is data.
-const bootstrap="import(Buffer.from(process.argv[1],'base64').toString('utf8')).then(module=>module.runHook()).catch(()=>{process.stderr.write('ARC Git guard failed to load\\n');process.exitCode=2;});";
-const prefix=`node -e "eval(Buffer.from('${Buffer.from(bootstrap).toString('base64')}','base64').toString('utf8'))" `;
-export function buildClaudeHookCommand(scriptPath) {
-  if(typeof scriptPath!=='string'||/[\x00-\x1f]/.test(scriptPath)||!path.isAbsolute(scriptPath)&&!path.win32.isAbsolute(scriptPath))throw Error('Claude hook requires an absolute script path');
-  let url;
-  if(path.win32.isAbsolute(scriptPath)&&/^[A-Za-z]:[\\/]/.test(scriptPath)) {
-    const normalized=path.win32.normalize(scriptPath).replaceAll('\\','/');url='file:///'+normalized.split('/').map((part,i)=>i===0?part:encodeURIComponent(part)).join('/');
-  } else {if(!path.isAbsolute(scriptPath)||path.normalize(scriptPath)!==scriptPath)throw Error('Invalid absolute hook path');url=pathToFileURL(scriptPath).href;}
-  return prefix+`"${Buffer.from(url).toString('base64')}"`;
-}
-export const templateHookCommand=buildClaudeHookCommand('/__ARC_INSTALLED_SKILL__/hooks/role-git-guard.mjs');
-export function validateClaudeHookCommand(command) {
-  if(typeof command!=='string'||!command.startsWith(prefix))throw Error('Unmanaged Claude hook command');
-  const encoded=/^"([A-Za-z0-9+/]+={0,2})"$/.exec(command.slice(prefix.length));if(!encoded)throw Error('Invalid Claude hook command');
-  const decoded=Buffer.from(encoded[1],'base64');if(decoded.toString('base64')!==encoded[1])throw Error('Invalid hook path encoding');
-  const url=new URL(decoded.toString('utf8'));if(url.protocol!=='file:'||url.host||!['/hooks/role-git-guard.mjs','/hooks/runtime-gate.mjs'].some(suffix=>url.pathname.endsWith(suffix))||url.search||url.hash)throw Error('Invalid hook file URL');
-  return command;
-}
-function entry(command,matcher,eol){
- validateClaudeHookCommand(command);
- return [`    - matcher: ${matcher}`,'      hooks:','        - type: command',`          command: ${JSON.stringify(command)}`,'          onFailure: block'].join(eol);
-}
-function entries(skillPath,eol){
- return entry(buildClaudeHookCommand(path.join(skillPath,'hooks/role-git-guard.mjs')),'Bash',eol);
-}
-export function hookFrontmatter(command=templateHookCommand,eol='\n') {
- validateClaudeHookCommand(command);
- return ['hooks:','  PreToolUse:',entry(command,'Bash',eol)].join(eol);
-}
-function update(text,skillPath,requireManaged){
- const eol=/\r?\n/.exec(text)?.[0]??'\n';
- const fm=/^---\r?\n([\s\S]*?)\r?\n---(?=\r?\n|$)/.exec(text);
- if(!fm)throw Error('Missing Claude frontmatter for hook generation');
- let lines=fm[1].split(/\r?\n/);
- const headers=lines.flatMap((line,i)=>/^hooks:/.test(line)?[i]:[]);
- if(headers.length>1)throw Error('Duplicate Claude hooks');
- let count=0;
- if(headers.length){
-  const h=headers[0];if(lines[h]!=='hooks:')throw Error('Malformed Claude hooks');
-  let end=h+1;while(end<lines.length&&(/^[ \t]/.test(lines[end])||lines[end]===''))end++;
-  const indexes=[];for(let i=h+1;i<end;i++)if(/^  PreToolUse:/.test(lines[i]))indexes.push(i);
-  if(indexes.length>1)throw Error('Duplicate PreToolUse');
-  if(indexes.length){
-   const pre=indexes[0];if(lines[pre]!=='  PreToolUse:')throw Error('Malformed PreToolUse');
-   let finish=pre+1;while(finish<end&&!/^  \S/.test(lines[finish]))finish++;
-   const kept=[];const seen=new Set();
-   for(let i=pre+1;i<finish;){
-    if(lines[i]===''){kept.push(lines[i++]);continue;}
-    if(!/^    - /.test(lines[i]))throw Error('Malformed Claude hook entry');
-    let j=i+1;while(j<finish&&!/^    - /.test(lines[j]))j++;
-    const chunk=lines.slice(i,j),body=chunk.join('\n');
-    const commands=chunk.filter(line=>/^          command: /.test(line));
-    const managed=commands.some(line=>{try{validateClaudeHookCommand(JSON.parse(line.slice('          command: '.length)));return true;}catch{return false;}});
-    if(managed){
-     if(commands.length!==1)throw Error('Malformed managed Claude hook');
-     const command=JSON.parse(commands[0].slice('          command: '.length));
-     const encoded=/"([A-Za-z0-9+/]+={0,2})"$/.exec(command)[1];const file=new URL(Buffer.from(encoded,'base64').toString('utf8')).pathname.split('/').at(-1);
-     if(seen.has(file))throw Error('Duplicate managed Claude hook');seen.add(file);count++;
-     const matcher=file==='runtime-gate.mjs'?'    - matcher: "*"':'    - matcher: Bash';
-     const base=[matcher,'      hooks:','        - type: command',commands[0]];
-     // Legacy four-line guard upgrades once; malformed failure behavior is never repaired silently.
-     if(JSON.stringify(chunk)!==JSON.stringify(base)&&JSON.stringify(chunk)!==JSON.stringify([...base,'          onFailure: block']))throw Error('Malformed managed Claude hook');
-    }else{
-     if(body.includes(prefix)||/role-git-guard\.mjs|runtime-gate\.mjs/.test(body))throw Error('Malformed managed Claude hook command');
-     kept.push(...chunk);
-    }
-    i=j;
-   }
-   lines.splice(pre+1,finish-pre-1,...kept,...entries(skillPath,eol).split(eol));
-  }else lines.splice(end,0,'  PreToolUse:',...entries(skillPath,eol).split(eol));
- }else lines.push('hooks:','  PreToolUse:',...entries(skillPath,eol).split(eol));
- if(requireManaged&&!count)throw Error('Missing managed Claude hook');
- const replacement='---'+eol+lines.join(eol)+eol+'---';
- return replacement+text.slice(fm[0].length);
-}
-export function installClaudeHook(bytes,skillPath){return Buffer.from(update(bytes.toString('utf8'),skillPath,true));}
-export function renderSourceClaudeHook(text){return update(text,'/__ARC_INSTALLED_SKILL__',false);}

package/scripts/probe-runtime-hooks.mjs

@@ -1,55 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import {pathToFileURL} from 'node:url';
-import {summarizeProbe} from '../lib/runtime/capabilities.mjs';
-
-// This tool does not install hooks, grant trust, or execute the tool being probed.
-// Host-result receipts must be supplied by the trusted probe host after checking
-// actual non-execution. A hook-decision receipt alone never verifies denial.
-export function writeProbeReceipt(receipt,data,write = fs.writeFileSync) {
-    let fd;
-    try {
-      fd=fs.openSync(receipt,fs.constants.O_WRONLY|fs.constants.O_CREAT|fs.constants.O_EXCL|fs.constants.O_NOFOLLOW,0o600);
-      write(fd,JSON.stringify(data)+'\n');
-    } catch(error) {
-      if(fd !== undefined) fs.unlinkSync(receipt);
-      throw error;
-    } finally { if(fd !== undefined) fs.closeSync(fd); }
-}
-
-if(process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
-try {
-  const [mode,...args] = process.argv.slice(2);
-  const options = {};
-  for(let i=0;i<args.length;i+=2) {
-    if(!['--platform','--session','--version','--receipt','--attempt','--scratch'].includes(args[i]) || !args[i+1]) throw new Error('Invalid probe options');
-    options[args[i].slice(2)] = args[i+1];
-  }
-  const {platform,session:sessionRef,version:platformVersion,attempt:attemptRef,scratch,receipt} = options;
-  if(!['codex','claude'].includes(platform) || !sessionRef || !platformVersion || !attemptRef || !receipt || !path.isAbsolute(receipt)) throw new Error('Explicit platform, session, version and absolute scratch receipt required');
-  if(mode === 'summary') {
-    const parsed = JSON.parse(fs.readFileSync(receipt,'utf8'));
-    console.log(JSON.stringify(summarizeProbe(Array.isArray(parsed)?parsed:[parsed],{platform,sessionRef,platformVersion,attemptRef})));
-  } else if(mode === 'hook') {
-    const input = JSON.parse(fs.readFileSync(0,'utf8'));
-    if(input.hook_event_name !== 'PreToolUse' || typeof input.tool_name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,79}$/.test(input.tool_name)) throw new Error('Only PreToolUse canary requests supported');
-    if(!scratch || !path.isAbsolute(scratch)) throw new Error('Explicit private scratch directory required');
-    const realScratch=fs.realpathSync(scratch);
-    const stat=fs.lstatSync(scratch);
-    if(stat.isSymbolicLink() || !stat.isDirectory() || (stat.mode & 0o077) !== 0 ||
-      (typeof process.getuid === 'function' && stat.uid !== process.getuid()) ||
-      path.dirname(realScratch) !== fs.realpathSync(os.tmpdir()) ||
-      !path.basename(realScratch).startsWith('arc-runtime-probe-') ||
-      fs.realpathSync(path.dirname(path.resolve(receipt))) !== realScratch) throw new Error('Receipt must be directly inside private probe scratch');
-    const data={source:'native',kind:'hook-decision',platform,platformVersion,sessionRef,attemptRef,
-      event:'PreToolUse',toolPath:input.tool_name,
-      operation:input.tool_name === 'Agent' ? (platform === 'codex' ? 'spawn_agent' : 'Agent') : null,decision:'deny'};
-    // Exclusive creation prevents truncation and symlink following. No staging
-    // file is needed; remove our own new receipt if its write fails.
-    writeProbeReceipt(receipt,data);
-    console.log(JSON.stringify({hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason:'ARC scratch canary deny'}}));
-  } else throw new Error('Expected hook or summary mode');
-} catch(error) { console.error(error.message); process.exitCode=1; }
-
-}