antisketch 0.0.0-stage → 1.2.1

package/app/server/mcp.js

@@ -0,0 +1,15 @@
+import {prepareLibrary} from './library.js';
+import {ROOT,DATA as libraryData,APPROVED as libraryApproved} from './config.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
+import {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';
+import {z} from 'zod';
+import {APPROVED} from './config.js';
+import {listReleaseFiles,verifyRelease} from './releases.js';
+await prepareLibrary({root:ROOT,data:libraryData,approved:libraryApproved});
+const server=new McpServer({name:'antisketch',version:'1.0.0'});
+const output=data=>({content:[{type:'text',text:typeof data==='string'?data:JSON.stringify(data,null,2)}]});
+server.registerTool('list_approved_designs',{description:'List personal design skills explicitly approved by the owner. Does not expose drafts.',inputSchema:{},annotations:{readOnlyHint:true,destructiveHint:false,openWorldHint:false}},async()=>output(listReleaseFiles(APPROVED).map(({folder,...release})=>release)));
+server.registerTool('read_design_skill',{description:'Read an approved design skill, its specification, or measured tokens. No modification or approval is possible through this tool.',inputSchema:{name:z.string().max(64),version:z.number().int().positive().optional(),part:z.enum(['skill','specification','tokens','evidence']).default('skill')},annotations:{readOnlyHint:true,destructiveHint:false,openWorldHint:false}},async({name,version,part})=>{try{const releases=listReleaseFiles(APPROVED).filter(r=>r.name===name&&(!version||r.version===version)).sort((a,b)=>b.version-a.version);if(!releases.length)return {...output('Approved skill not found'),isError:true};const release=releases[0];verifyRelease(release.folder);const file={skill:'SKILL.md',specification:'references/specification.md',tokens:'references/tokens.json',evidence:'references/evidence.json'}[part];return output(fs.readFileSync(path.join(release.folder,file),'utf8'));}catch(e){return {...output(e.message),isError:true};}});
+await server.connect(new StdioServerTransport());

package/app/server/network.js

@@ -0,0 +1,23 @@
+import dns from 'node:dns/promises';
+import http from 'node:http';
+import net from 'node:net';
+import ipaddr from 'ipaddr.js';
+export function publicAddress(address){try{let ip=ipaddr.parse(address);if(ip.kind()==='ipv6'&&ip.isIPv4MappedAddress())ip=ip.toIPv4Address();return ip.range()==='unicast';}catch{return false;}}
+export function normalizeURL(input){let u;try{u=new URL(input.includes('://')?input:'https://'+input);}catch{throw new Error('Enter a valid website address');}if(!['http:','https:'].includes(u.protocol)||u.username||u.password)throw new Error('Use a public HTTP or HTTPS website without embedded credentials');if(u.port&&!['80','443'].includes(u.port))throw new Error('Only standard web ports (80 and 443) are supported');u.hash='';return u.href;}
+export async function resolvePublic(host,allowLoopback=false){host=host.replace(/^\[|\]$/g,'');const addresses=net.isIP(host)?[{address:host,family:net.isIP(host)}]:await dns.lookup(host,{all:true});if(!addresses.length||addresses.some(a=>!publicAddress(a.address)&&!(allowLoopback&&a.address==='127.0.0.1')))throw new Error('Private, local, and reserved network addresses cannot be captured');return addresses.find(a=>a.family===4)||addresses[0];}
+export async function validateURL(input){const url=normalizeURL(input);await resolvePublic(new URL(url).hostname);return url;}
+// Resolve once, validate every answer, then connect to that exact IP. This also
+// protects redirects and subresources against DNS rebinding and private networks.
+export async function startCaptureProxy({allowLoopback=false}={}){
+ const sockets=new Set();
+ const track=s=>{sockets.add(s);s.on('close',()=>sockets.delete(s));s.on('error',()=>{});s.setTimeout(45000,()=>s.destroy());return s;};
+ const server=http.createServer(async(req,res)=>{try{
+  const u=new URL(req.url);if(u.protocol!=='http:'||(!allowLoopback&&u.port&&u.port!=='80')||!['GET','HEAD'].includes(req.method))throw new Error('Request not allowed');
+  const ip=await resolvePublic(u.hostname,allowLoopback);
+  const upstream=http.request({host:ip.address,family:ip.family,port:u.port||80,path:u.pathname+u.search,method:req.method,headers:{...req.headers,host:u.host,connection:'close'}},r=>{res.writeHead(r.statusCode,r.headers);r.pipe(res);});upstream.on('socket',track);upstream.on('error',()=>{if(!res.headersSent)res.writeHead(502);res.end();});req.pipe(upstream);
+ }catch{res.writeHead(403);res.end('Capture network policy blocked this address');}});
+ server.on('connection',track);
+ server.on('connect',async(req,client,head)=>{try{const u=new URL('https://'+req.url);if((u.port||'443')!=='443')throw new Error('Port blocked');const ip=await resolvePublic(u.hostname,allowLoopback);const upstream=track(net.connect({host:ip.address,port:443,family:ip.family},()=>{client.write('HTTP/1.1 200 Connection Established\r\n\r\n');if(head.length)upstream.write(head);client.pipe(upstream);upstream.pipe(client);}));upstream.on('error',()=>client.destroy());client.on('close',()=>upstream.destroy());}catch{client.end('HTTP/1.1 403 Forbidden\r\n\r\n');}});
+ await new Promise((resolve,reject)=>{server.once('error',reject);server.listen(0,'127.0.0.1',resolve);});
+ return {url:`http://127.0.0.1:${server.address().port}`,close:async()=>{for(const s of sockets)s.destroy();await new Promise(r=>server.close(r));}};
+}

package/app/server/package.js

@@ -0,0 +1,33 @@
+import {embedFonts} from './demo-fonts.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import {atomic,inventory,readJSON,slug} from './files.js';
+export const DEMO_CSP="sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; font-src data:; connect-src 'none'; form-action 'none'; base-uri 'none'; frame-src 'none'; object-src 'none'";
+export function secureDemo(html){return '<!doctype html><meta http-equiv="Content-Security-Policy" content="'+DEMO_CSP.replace('sandbox allow-scripts; ','')+'">\n'+html;}
+function dtcg(t){
+ if(t.category==='color'){const m=t.value.match(/^rgba?\(([\d.]+)[, ]+([\d.]+)[, ]+([\d.]+)(?:[, /]+([\d.]+))?\)$/);if(m)return {$type:'color',$value:{colorSpace:'srgb',components:m.slice(1,4).map(v=>Number(v)/255),alpha:m[4]===undefined?1:Number(m[4])}};if(/^#[a-f0-9]{6}$/i.test(t.value))return {$type:'color',$value:{colorSpace:'srgb',components:[1,3,5].map(i=>parseInt(t.value.slice(i,i+2),16)/255),alpha:1}};}
+ if(t.category==='fontFamily')return {$type:'fontFamily',$value:t.value.split(',').map(v=>v.trim().replace(/^['"]|['"]$/g,''))};
+ if(['dimension','spacing','radius'].includes(t.category)&&/^-?[\d.]+px$/.test(t.value))return {$type:'dimension',$value:{value:parseFloat(t.value),unit:'px'}};
+ if(t.category==='motion'&&/^[\d.]+m?s$/.test(t.value))return {$type:'duration',$value:{value:parseFloat(t.value),unit:t.value.endsWith('ms')?'ms':'s'}};
+ return null;
+}
+export function materialize(capture,result,dir){
+ const tokens=result.tokenReferences.map(ref=>({...capture.candidates.find(t=>t.id===ref.id),name:ref.name,role:ref.role,classification:'observed',scope:'Captured elements and viewports; resolved CSS values'}));
+ const typed={};for(const t of tokens){const value=dtcg(t);if(value)typed[t.name]={...value,$description:t.role,$extensions:{'antisketch':{evidence:t.evidence,scope:t.scope}}};}
+ atomic(path.join(dir,'tokens.json'),{version:1,tokens});atomic(path.join(dir,'tokens.dtcg.json'),typed);atomic(path.join(dir,'specification.md'),result.specification);
+ result.demos.forEach((d,i)=>atomic(path.join(dir,`demo-${i+1}.html`),secureDemo(embedFonts(d.artwork?d.html.replace('<!--ANTISKETCH_ART-->',d.artwork.svg):d.html))));
+ const summary={visualReview:result.visualReview,concepts:result.concepts,name:result.name,summary:result.summary,principles:result.principles,limitations:[...capture.warnings,...capture.coverage.limits,...result.limitations],demos:result.demos.map((d,i)=>({id:i+1,title:d.title,brief:d.brief,file:`demo-${i+1}.html`}))};atomic(path.join(dir,'summary.json'),summary);return summary;
+}
+export function buildRelease({design,revision,version,selectedDemo,note,checks,sourceDir,releaseDir}){
+ if(fs.existsSync(releaseDir))throw new Error('This release already exists');
+ const summary=readJSON(path.join(sourceDir,'summary.json'));const name=slug(summary.name)+'-'+design.id.slice(0,8);const demo=summary.demos.find(d=>d.id===selectedDemo);if(!demo)throw new Error('Choose a final demo');
+ const stage=releaseDir+'.pending';fs.rmSync(stage,{recursive:true,force:true});fs.mkdirSync(path.join(stage,'references'),{recursive:true});fs.mkdirSync(path.join(stage,'assets'),{recursive:true});
+ try{
+ for(const file of ['tokens.json','tokens.dtcg.json','specification.md'])fs.copyFileSync(path.join(sourceDir,file),path.join(stage,'references',file));
+ fs.copyFileSync(path.join(sourceDir,demo.file),path.join(stage,'assets','demo.html'));
+ atomic(path.join(stage,'references','evidence.json'),{source:design.url,capturedAt:readJSON(path.join(sourceDir,'capture.json')).capturedAt,principles:summary.principles,measurements:readJSON(path.join(sourceDir,'capture.json')).pages.map(p=>({id:p.id,url:p.url,viewport:p.viewport,elements:p.elements,variables:p.variables,measurements:p.measurements})),limitations:summary.limitations});
+ atomic(path.join(stage,'SKILL.md'),`---\nname: ${name}\ndescription: ${JSON.stringify(`Apply the ${summary.name} design language to interfaces when this aesthetic is requested. Use scoped tokens and adapt composition to the target task.`)}\n---\n\n# ${summary.name}\n\n${summary.summary}\n\nRead [the design specification](references/specification.md) before designing. Use [scoped tokens and their evidence](references/tokens.json); [typed tokens](references/tokens.dtcg.json) contain the subset representable in DTCG format.\n\n${summary.principles.map(p=>`- **${p.title}:** ${p.description} (${p.classification})`).join('\n')}\n\nOpen [the approved example](assets/demo.html) to understand the visual relationships. It demonstrates ${demo.title}: ${demo.brief}\n\nPreserve the aesthetic relationships while choosing a composition and interaction model suited to the user's task. The example's layout and subject matter are not mandatory. Source defects and untested behaviors are not reusable design rules. Read [evidence and limits](references/evidence.json) when precision matters. The reference website's images, logos, and fonts are not licensed for reuse by this skill.\n\nThis release was approved as version ${version}; later drafts do not change it.\n`);
+ atomic(path.join(stage,'approval.json'),{version,designId:design.id,revision,selectedDemo,approvedAt:new Date().toISOString(),approvedBy:'local-owner',note,checks,sourceURL:design.url});
+ atomic(path.join(stage,'manifest.json'),{formatVersion:1,name,version,files:inventory(stage)});fs.mkdirSync(path.dirname(releaseDir),{recursive:true});fs.renameSync(stage,releaseDir);return name;
+ }catch(e){fs.rmSync(stage,{recursive:true,force:true});throw e;}
+}

package/app/server/releases.js

@@ -0,0 +1,8 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {readJSON,contained,hash} from './files.js';
+export function listReleaseFiles(root){if(!fs.existsSync(root))return [];const releases=[];for(const design of fs.readdirSync(root,{withFileTypes:true})){if(!design.isDirectory()||!/^[-a-z0-9]+$/.test(design.name))continue;for(const version of fs.readdirSync(path.join(root,design.name),{withFileTypes:true})){if(!version.isDirectory()||!/^v\d+$/.test(version.name))continue;const folder=path.join(root,design.name,version.name);try{const manifest=readJSON(path.join(folder,'manifest.json')),approval=readJSON(path.join(folder,'approval.json'));releases.push({name:manifest.name,version:manifest.version,designId:approval.designId,revision:approval.revision,approvedAt:approval.approvedAt,folder});}catch{}}}return releases;}
+export function verifyRelease(folder){const manifest=readJSON(path.join(folder,'manifest.json'));if(!Array.isArray(manifest.files)||!manifest.files.length)throw new Error('Release manifest is missing');for(const f of manifest.files)if(hash(contained(folder,f.path))!==f.sha256)throw new Error('Release integrity check failed');return manifest;}
+// Finish an approval whose files were atomically committed before a process crash.
+// Only packages containing a valid explicit approval record are reconciled.
+export function recoverReleases(store,root){for(const release of listReleaseFiles(root)){if(store.db.prepare('SELECT id FROM releases WHERE design_id=? AND revision=?').get(release.designId,release.revision))continue;const d=store.design(release.designId),r=store.revision(release.designId,release.revision);if(!d||!r)continue;try{verifyRelease(release.folder);const approval=readJSON(path.join(release.folder,'approval.json'));if(!approval.checks?.reference||!approval.checks?.transfer||!approval.checks?.limits||approval.approvedBy!=='local-owner')continue;store.db.transaction(()=>{store.db.prepare('INSERT INTO releases VALUES(?,?,?,?,?,?)').run(`${release.designId}-recovered-${release.version}`,release.designId,release.revision,release.version,path.relative(root,release.folder),release.approvedAt);store.stage(release.designId,release.revision,'approved',`Recovered approved skill version ${release.version}`);})();}catch{ /* Keep an inconsistent package untouched for manual recovery. */ }}}

package/app/server/setup.js

@@ -0,0 +1,6 @@
+import {launchBrowser} from './capture.js';
+let cached=null;
+export async function browserStatus({fresh=false}={}){
+ if(!fresh&&cached&&Date.now()-cached.at<60000)return cached.promise;
+ const promise=(async()=>{let browser;try{browser=await launchBrowser({timeout:10000});return {ready:true,message:'Browser ready for captures.'};}catch{return {ready:false,message:'Install Google Chrome, then check again. Antisketch needs a local browser to capture references.',downloadURL:'https://www.google.com/chrome/'};}finally{await browser?.close();}})();cached={at:Date.now(),promise};return promise;
+}

package/app/server/store.js

@@ -0,0 +1,25 @@
+import Database from 'better-sqlite3';
+import {databasePath} from './compat.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {DATA,ACTIVE,now} from './config.js';
+export function openStore(dir=DATA){
+ fs.mkdirSync(dir,{recursive:true});const db=new Database(databasePath(dir));
+ db.pragma('journal_mode = WAL');db.pragma('foreign_keys = ON');db.pragma('busy_timeout = 5000');
+ db.exec(`CREATE TABLE IF NOT EXISTS designs(id TEXT PRIMARY KEY,url TEXT NOT NULL,name TEXT NOT NULL,notes TEXT NOT NULL DEFAULT '',current_revision INTEGER NOT NULL DEFAULT 1,archived INTEGER NOT NULL DEFAULT 0,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+ CREATE TABLE IF NOT EXISTS revisions(design_id TEXT NOT NULL REFERENCES designs(id),number INTEGER NOT NULL,status TEXT NOT NULL,stage TEXT NOT NULL DEFAULT '',feedback TEXT NOT NULL DEFAULT '',error TEXT,created_at TEXT NOT NULL,updated_at TEXT NOT NULL,PRIMARY KEY(design_id,number));
+ CREATE TABLE IF NOT EXISTS events(id INTEGER PRIMARY KEY AUTOINCREMENT,design_id TEXT NOT NULL,revision INTEGER NOT NULL,kind TEXT NOT NULL,message TEXT NOT NULL,created_at TEXT NOT NULL);
+ CREATE TABLE IF NOT EXISTS releases(id TEXT PRIMARY KEY,design_id TEXT NOT NULL REFERENCES designs(id),revision INTEGER NOT NULL,version INTEGER NOT NULL,folder TEXT NOT NULL,created_at TEXT NOT NULL,UNIQUE(design_id,revision),UNIQUE(design_id,version));
+ PRAGMA user_version = 1;`);
+ const design=id=>db.prepare('SELECT * FROM designs WHERE id=?').get(id);
+ const revision=(id,n)=>db.prepare('SELECT * FROM revisions WHERE design_id=? AND number=?').get(id,n);
+ const event=(id,n,kind,message)=>db.prepare('INSERT INTO events(design_id,revision,kind,message,created_at) VALUES(?,?,?,?,?)').run(id,n,kind,message,now());
+ function stage(id,n,status,message,error=null){db.transaction(()=>{db.prepare('UPDATE revisions SET status=?,stage=?,error=?,updated_at=? WHERE design_id=? AND number=?').run(status,message,error,now(),id,n);db.prepare('UPDATE designs SET updated_at=? WHERE id=?').run(now(),id);event(id,n,status,message);})();}
+ function create(url,notes=''){const id=crypto.randomUUID(),date=now();db.transaction(()=>{db.prepare('INSERT INTO designs(id,url,name,notes,created_at,updated_at) VALUES(?,?,?,?,?,?)').run(id,url,new URL(url).hostname,notes,date,date);db.prepare('INSERT INTO revisions(design_id,number,status,stage,created_at,updated_at) VALUES(?,1,?,?,?,?)').run(id,'queued','Waiting to capture',date,date);event(id,1,'queued','Website added to your inbox');})();return design(id);}
+ function revise(id,feedback){return db.transaction(()=>{const d=design(id);if(!d)throw new Error('Design not found');const r=revision(id,d.current_revision);if(ACTIVE.includes(r.status))throw new Error('This design is still being prepared');const n=d.current_revision+1,date=now();db.prepare('UPDATE designs SET current_revision=?,updated_at=? WHERE id=?').run(n,date,id);db.prepare('INSERT INTO revisions(design_id,number,status,stage,feedback,created_at,updated_at) VALUES(?,?,?,?,?,?,?)').run(id,n,'queued','Waiting to prepare revision',feedback,date,date);event(id,n,'queued',feedback||'Capture and extraction requested again');return n;})();}
+ function list(){return db.prepare(`SELECT d.*,r.status,r.stage,r.error,(SELECT COUNT(*) FROM releases a WHERE a.design_id=d.id) AS release_count FROM designs d JOIN revisions r ON r.design_id=d.id AND r.number=d.current_revision ORDER BY d.updated_at DESC`).all();}
+ function detail(id){const d=design(id);if(!d)return null;return {...d,revisions:db.prepare('SELECT * FROM revisions WHERE design_id=? ORDER BY number DESC').all(id),events:db.prepare('SELECT * FROM events WHERE design_id=? ORDER BY id DESC LIMIT 100').all(id),releases:db.prepare('SELECT * FROM releases WHERE design_id=? ORDER BY version DESC').all(id)};}
+ function recover(){for(const r of db.prepare("SELECT * FROM revisions WHERE status IN ('capturing','interpreting','validating')").all())stage(r.design_id,r.number,'failed','Preparation was interrupted. Retry to continue.','The app stopped before this revision was complete. Previously approved versions are unchanged.');}
+ return {db,design,revision,event,stage,create,revise,list,detail,recover,close:()=>db.close()};
+}

package/app/server/validate.js

@@ -0,0 +1,48 @@
+import {interactionSchema} from './interaction-contract.js';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import {launchBrowser} from './capture.js';
+import {DEMO_CSP} from './package.js';
+import {atomic,readJSON} from './files.js';
+export async function validateDemos(dir,{signal}={}){
+ const contractsFile=path.join(dir,'interaction-tests.json');
+ const contracts=fs.existsSync(contractsFile)?readJSON(contractsFile).demos:[];
+ const server=http.createServer((req,res)=>{const m=req.url.match(/^\/demo-([12])\.html$/);if(!m){res.writeHead(404).end();return;}res.writeHead(200,{'Content-Type':'text/html','Content-Security-Policy':DEMO_CSP});res.end(fs.readFileSync(path.join(dir,`demo-${m[1]}.html`)));});
+ await new Promise(r=>server.listen(0,'127.0.0.1',r));let browser;const checks=[];
+ try{browser=await launchBrowser();const abort=()=>browser.close().catch(()=>{});signal?.addEventListener('abort',abort,{once:true});try{
+  for(const demo of [1,2])for(const width of [1440,390]){
+   signal?.throwIfAborted();const page=await browser.newPage({viewport:{width,height:900},hasTouch:width===390,isMobile:width===390});const errors=[];page.on('pageerror',e=>errors.push(e.message.slice(0,300)));page.on('dialog',d=>d.dismiss().catch(()=>{}));await page.route('**/*',r=>r.request().url().startsWith(`http://127.0.0.1:${server.address().port}/demo-`)?r.continue():r.abort());
+   await page.goto(`http://127.0.0.1:${server.address().port}/demo-${demo}.html`,{waitUntil:'load',timeout:15000});await page.evaluate(()=>document.fonts.ready);await page.waitForTimeout(200);
+   const info=await page.evaluate(()=>({overflow:document.documentElement.scrollWidth>innerWidth+2,textLength:document.body.innerText.length,controls:document.querySelectorAll('button,input,select,textarea').length,brokenImages:[...document.images].filter(image=>!image.complete||image.naturalWidth===0).length}));
+   const unnamed=await page.locator('button').evaluateAll(es=>es.filter(e=>!e.textContent.trim()&&!e.getAttribute('aria-label')&&!e.getAttribute('title')).length);
+   const issues=[...errors,...(info.brokenImages?['An image could not load in the offline sandbox']:[]),...(info.overflow?['Horizontal page overflow']:[]),...(info.textLength<80?['Demo has too little visible content']:[]),...(info.controls===0?['No interactive controls found']:[]),...(unnamed?['A button has no accessible name']:[])];
+   const screenshot=`demo-${demo}-${width}.png`;await page.screenshot({path:path.join(dir,screenshot),fullPage:true,timeout:15000});const interactions=[];
+   for(const raw of (contracts.find(c=>c.demo===demo)?.tests||[]).slice(0,4)){
+    const test=interactionSchema.parse(raw);
+    try{
+     // A fresh document for each contract; only a small declarative action vocabulary is allowed.
+     await page.reload({waitUntil:'load',timeout:15000});page.setDefaultTimeout(2500);
+     const target=page.locator(test.assertion.selector).first();
+     const before=test.assertion.kind==='textChanged'?await target.innerText():null;
+     for(const step of test.steps){signal?.throwIfAborted();const el=page.locator(step.selector).first();
+      if(step.action==='click')await el.click();else if(step.action==='fill')await el.fill(step.value);else if(step.action==='select')await el.selectOption(step.value);else await el.press(step.value);
+     }
+     const deadline=Date.now()+2500;let passed=false;
+     do{
+      const a=test.assertion;
+      passed=a.kind==='visible'?await target.isVisible():a.kind==='attributeEquals'?(await target.getAttribute(a.attribute))===a.value:a.kind==='textIncludes'?(await target.innerText()).includes(a.value):(await target.innerText())!==before;
+      if(!passed)await page.waitForTimeout(100);
+     }while(!passed&&Date.now()<deadline);
+     if(!passed)throw new Error('Expected visible result was not observed');
+     const overflow=await page.evaluate(()=>document.documentElement.scrollWidth>innerWidth+2);if(overflow)throw new Error('Horizontal overflow after interaction');
+     interactions.push({name:test.name,passed:true});
+    }catch(e){if(signal?.aborted)throw e;const issue=`${test.name}: ${e.message.slice(0,240)}`;issues.push(issue);interactions.push({name:test.name,passed:false,issue});}
+   }
+   for(const error of errors)if(!issues.includes(error))issues.push(error);
+   checks.push({demo,width,passed:issues.length===0,issues,screenshot,controls:info.controls,interactions});await page.close();
+  }
+ }finally{signal?.removeEventListener('abort',abort);}
+ }finally{await browser?.close().catch(()=>{});await new Promise(r=>server.close(r));}
+ const result={passed:checks.every(c=>c.passed),checkedAt:new Date().toISOString(),checks,scope:'Chromium desktop/mobile render checks, overflow, runtime errors, button names, and declared interaction workflows where supplied. Visual critique is advisory; completeness and aesthetic quality still need your review.'};atomic(path.join(dir,'validation.json'),result);return result;
+}

package/app/server/worker.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {DESIGNS,ACTIVE} from './config.js';
+import {capture} from './capture.js';
+import {interpret} from './interpret.js';
+import {materialize} from './package.js';
+import {validateDemos} from './validate.js';
+import {readJSON} from './files.js';
+export const revisionDir=(id,n,root=DESIGNS)=>path.join(root,id,'revisions',String(n));
+export function createWorker(store,{designsDir=DESIGNS,captureFn=capture,interpretFn=interpret,validateFn=validateDemos}={}){
+ let active=null,closed=false;const dir=(id,n)=>revisionDir(id,n,designsDir);
+ async function tick(){if(active||closed)return;const job=store.db.prepare("SELECT r.* FROM revisions r JOIN designs d ON d.id=r.design_id WHERE r.status='queued' AND d.archived=0 ORDER BY r.created_at LIMIT 1").get();if(!job)return;
+  const controller=new AbortController();active={id:job.design_id,n:job.number,controller};const timeout=setTimeout(()=>controller.abort(new Error('Preparation exceeded the 45-minute time limit')),45*60*1000);const target=dir(job.design_id,job.number);
+  const update=(status,message)=>{controller.signal.throwIfAborted();store.stage(job.design_id,job.number,status,message);};
+  try{const design=store.design(job.design_id);fs.mkdirSync(target,{recursive:true});let evidence,previous=null,direction=null;const last=dir(job.design_id,job.number-1);
+   if(job.feedback){const prior=['interpretation.json','direction.json'].find(file=>fs.existsSync(path.join(last,file)));if(prior)previous=readJSON(path.join(last,prior));}
+   if(job.feedback&&fs.existsSync(path.join(last,'capture.json'))&&readJSON(path.join(last,'capture.json')).version>=2){update('capturing','Reusing the previous capture for your requested changes');fs.cpSync(path.join(last,'evidence'),path.join(target,'evidence'),{recursive:true});fs.copyFileSync(path.join(last,'capture.json'),path.join(target,'capture.json'));evidence=readJSON(path.join(target,'capture.json'));const prior=store.revision(job.design_id,job.number-1);if(['failed','cancelled'].includes(prior?.status)&&prior.feedback===job.feedback&&fs.existsSync(path.join(last,'direction.json'))){direction=readJSON(path.join(last,'direction.json'));for(const name of ['artwork-experiment-1.json','artwork-experiment-2.json'])if(fs.existsSync(path.join(last,name)))fs.copyFileSync(path.join(last,name),path.join(target,name));}}
+   else{update('capturing','Opening the reference in a clean browser');evidence=await captureFn(design.url,target,{signal:controller.signal,onProgress:m=>update('capturing',m)});}
+   update('interpreting','Finding the design language and building examples');const result=await interpretFn(evidence,target,{notes:design.notes,feedback:job.feedback,previous,direction,signal:controller.signal,onProgress:m=>update('interpreting',m)});controller.signal.throwIfAborted();materialize(evidence,result,target);
+   update('validating','Checking desktop and mobile demos');const validation=await validateFn(target,{signal:controller.signal});controller.signal.throwIfAborted();store.db.prepare('UPDATE designs SET name=? WHERE id=?').run(result.name,design.id);update('review',validation.passed?'Ready for your eye':'Ready to inspect · demo issues need revision before approval');
+  }catch(e){const cancelled=store.revision(job.design_id,job.number)?.status==='cancelled';if(!cancelled)store.stage(job.design_id,job.number,'failed','This revision needs attention',controller.signal.aborted?controller.signal.reason?.message||'Preparation interrupted':e.message.slice(0,1500));}
+  finally{clearTimeout(timeout);active=null;if(!closed)setImmediate(tick);}
+ }
+ const interval=setInterval(tick,1500);interval.unref();
+ return {wake:()=>setImmediate(tick),cancel(id,n){const r=store.revision(id,n);if(!r||!ACTIVE.includes(r.status))throw new Error('Only an unfinished revision can be cancelled');store.stage(id,n,'cancelled','Preparation cancelled');if(active?.id===id&&active.n===n)active.controller.abort();},async close(){closed=true;clearInterval(interval);active?.controller.abort();while(active)await new Promise(r=>setTimeout(r,50));}};
+}

package/bin/antisketch

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const args=process.argv.slice(2),command=args[0]&&!args[0].startsWith('-')?args.shift():'start';
+if(args.includes('--help')||args.includes('-h')||command==='help'){
+ console.log('Usage: antisketch [start] [--no-open]\n       antisketch mcp\n       antisketch backup [destination]\n       antisketch restore <backup>\n\nOpen your local design workshop. Connect Codex in Studio settings.\nYour library lives outside the application and survives updates.\nKeep this Terminal open; Ctrl-C stops the server.');process.exit(0);
+}
+if(['mcp','backup','restore'].includes(command)){
+ if(command==='mcp'&&args.length)throw new Error('Usage: antisketch mcp');
+ process.argv=[process.execPath,command,...args];
+ await import(new URL(command==='mcp'?'../app/server/mcp.js':`../app/scripts/${command}.js`,import.meta.url));
+}else if(command==='start'){
+ if(args.some(arg=>arg!=='--no-open'))throw new Error('Unknown option. Run antisketch --help.');
+ const port=Number(process.env.PORT||4310);if(!Number.isInteger(port)||port<1||port>65535)throw new Error('PORT must be between 1 and 65535.');
+ const url=`http://127.0.0.1:${port}`,open=()=>{if(!args.includes('--no-open')){const child=spawn('open',[url],{stdio:'ignore'});child.on('error',()=>console.log('Open '+url+' in your browser.'));child.unref();}};
+ async function healthy(){try{const response=await fetch(url+'/api/health',{signal:AbortSignal.timeout(1200)});const result=await response.json();return ['antisketch','design-vault'].includes(result.app);}catch{return false;}}
+ if(await healthy()){console.log('Antisketch is already running at '+url);open();}
+ else{
+  process.chdir(root);
+  const timer=setInterval(async()=>{if(await healthy()){clearInterval(timer);open();}},400);timer.unref();
+  await import('../app/server/index.js');
+ }
+}else{console.error('Unknown command. Run antisketch --help.');process.exitCode=1;}

package/bin/design-vault

@@ -0,0 +1,3 @@
+#!/bin/zsh
+# Compatibility alias for existing installations.
+exec "${0:A:h}/antisketch" "$@"

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "antisketch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.1",
+  "type": "module",
+  "engines": {
+    "node": ">=20.17"
+  },
+  "scripts": {
+    "start": "node app/server/index.js",
+    "dev": "node --watch app/server/index.js",
+    "test": "node --test --test-concurrency=1 app/tests/*.test.js",
+    "test:browser": "node app/tests/browser.js",
+    "check": "node app/scripts/check.js",
+    "backup": "node app/scripts/backup.js",
+    "mcp": "node app/server/mcp.js",
+    "restore": "node app/scripts/restore.js",
+    "pack:preview": "node app/scripts/pack-preview.js",
+    "test:onboarding": "node app/tests/onboarding.js",
+    "test:distribution": "node app/tests/distribution.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.1",
+    "@openai/codex": "0.162.1",
+    "better-sqlite3": "12.11.1",
+    "express": "5.3.0",
+    "ipaddr.js": "2.5.0",
+    "playwright": "1.64.1",
+    "yazl": "3.3.1",
+    "zod": "4.6.7"
+  },
+  "bin": {
+    "antisketch": "bin/antisketch",
+    "design-vault": "bin/design-vault"
+  },
+  "description": "A local workshop for turning design references into reusable agent skills.",
+  "license": "MIT",
+  "author": "Harsh Joshi <harsh.joshi.pth@gmail.com>",
+  "homepage": "https://github.com/josharsh/antisketch#readme",
+  "bugs": {
+    "url": "https://github.com/josharsh/antisketch/issues"
+  },
+  "keywords": [
+    "design",
+    "design-system",
+    "design-tokens",
+    "agent-skills",
+    "codex",
+    "claude-code",
+    "playwright",
+    "mcp"
+  ],
+  "os": [
+    "darwin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/josharsh/antisketch.git"
+  },
+  "files": [
+    "bin/antisketch",
+    "bin/design-vault",
+    "app/server/",
+    "app/scripts/backup.js",
+    "app/scripts/restore.js",
+    "app/mcp.example.json",
+    "app/distribution/",
+    "app/public/index.html",
+    "app/public/app.js",
+    "app/public/setup.js",
+    "app/public/style.css",
+    "app/public/fonts/",
+    "app/public/brand/mark.svg",
+    "app/public/brand/favicon.svg",
+    "app/public/brand/identity.json",
+    "app/public/brand/identity.css",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}