stillmade-sdk 0.1.38 → 0.1.39

package/packages/block-cli/cli.js

@@ -21,7 +21,7 @@ import {realpathSync} from 'node:fs';
 import {numberedTakes} from '../block-sdk/state-example.js';
 import {initialBlockState,validateBlockState} from '../block-sdk/state.js';
 import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
-import { resolve, join, sep, dirname } from 'node:path';
+import { resolve, join, sep, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { textCleanup, lineArt, javascriptText } from '../block-sdk/examples.js';
 import {validateViewAppearance} from '../block-sdk/appearance.js';
@@ -84,20 +84,20 @@ const localFileReader=folder=>async name=>{
  const info=await lstat(full);if(!info.isFile())throw Object.assign(new Error(`${name} is not a file.`),{code:'MODULE_FILE_READ'});
  return new Uint8Array(await readFile(full));
 };
-async function standIns(path,pkg,requested){
+async function standIns(path,pkg,requested,pickedMedia){
  let mocks;const folder=await blockFolder(path);
  if(folder){try{mocks=JSON.parse(await readFile(join(folder,MOCKS_FILE),'utf8'));}catch(error){if(error.code!=='ENOENT')throw Object.assign(new Error(`${MOCKS_FILE}: ${error.message}`),{code:'MOCK_HOST'});}}
  if(!requested&&mocks===undefined)return null;
- return createMockHost({mocks:validateMocks(mocks),readLocalFile:localFileReader(folder),manifest:pkg.manifest});
+ return createMockHost({mocks:validateMocks(mocks),readLocalFile:localFileReader(folder),manifest:pkg.manifest,pickedMedia});
 }
 // A module fixture's own mocks take the place of tests/mocks.json for that fixture (MODULES.md), with or
 // without --mock, as ready and StillMade's import review already did (October 27, 2026: test, pack and dev
 // answered every fixture from tests/mocks.json, or left it unanswered when there was none).
 // Returns hostFor(mocks), a fresh stand-in host for one fixture, or null for other runtimes.
-async function fixtureStandIns(path,pkg){
+async function fixtureStandIns(path,pkg,pickedMedia){
  if(pkg.manifest?.runtime!=='module')return null;
  const readLocalFile=localFileReader(await blockFolder(path));
- return mocks=>createMockHost({mocks:validateMocks(mocks),readLocalFile,manifest:pkg.manifest});
+ return mocks=>createMockHost({mocks:validateMocks(mocks),readLocalFile,manifest:pkg.manifest,pickedMedia});
 }
 // A run whose input is a fixture's (dev's Example picker, run without an input file) uses that fixture's mocks.
 const fixtureFor=(pkg,input)=>pkg.manifest?.runtime==='module'?pkg.tests?.find(test=>test?.mocks&&stableStringify(test.input)===stableStringify(input)):undefined;
@@ -125,13 +125,17 @@ async function dev(path,options){
  if(!(await lstat(path)).isDirectory())throw Object.assign(new Error('dev previews a Block folder.'),{code:'USAGE'});
  const {startDevServer}=await import('./dev-server.js');
  let mock,mocksText,memory,answered;
+ // Files the person picks in the preview's own-file mode: kept in this process only, read by the run as themselves
+ // (November 1, 2026, owner: try a Block on your own video, not only its example).
+ const picked=new Map(),pickedMedia=url=>picked.get(url)||null;
+ const pick=(bytes,{mediaType,name})=>{const id=randomBytes(8).toString('hex'),safe=String(name||'file').replace(/[^\w.-]+/g,'-').slice(0,80)||'file',url=`/api/media/picked/${id}/${safe}`;picked.set(url,{bytes,mediaType});return url;};
  const load=async()=>{
   let pkg;
   try{pkg=await readPackage(path);}catch(error){return {problem:`${error.message}${error.code?` (${error.code})`:''}`};}
   let problem=null;
   try{validatePackage(pkg);appearanceAdvice(pkg.view);}catch(error){problem=error.message;}
   let text=null;try{text=await readFile(join(path,MOCKS_FILE),'utf8');}catch(error){if(error.code!=='ENOENT')problem=`${MOCKS_FILE}: ${error.message}`;}
-  if(!mock||text!==mocksText){try{mock=await standIns(path,pkg,true);mocksText=text;}catch(error){problem=error.message;}}
+  if(!mock||text!==mocksText){try{mock=await standIns(path,pkg,true,pickedMedia);mocksText=text;}catch(error){problem=error.message;}}
   memory=undefined;
   const files=moduleFiles.get(pkg)||{},filesBySha={};
   for(const [name,file] of [...Object.entries(pkg.module?.files||{}),...Object.entries(pkg.view?.files?.files||{}).map(([name,file])=>[`view:${name}`,file])])if(files[name])filesBySha[file.sha256]=files[name];
@@ -140,7 +144,7 @@ async function dev(path,options){
  const run=async(pkg,input)=>{
   const state=pkg.manifest.state?memory??initialBlockState(pkg.manifest):undefined;
   // The Example picker sends that example's input: unedited, it runs against the example's own mocks.
-  const fixture=fixtureFor(pkg,input),own=fixture?(await fixtureStandIns(path,pkg))(fixture.mocks):null;
+  const fixture=fixtureFor(pkg,input),own=fixture?(await fixtureStandIns(path,pkg,pickedMedia))(fixture.mocks):null;
   answered=own?{host:own,files:fixture.mocks.files}:null;
   const result=await runPackageAsync(pkg,input,{...(state?{state}:{}),...(pkg.manifest.runtime==='module'?{module:moduleExecutor(pkg,(own||mock)?.host)}:{}),...(pkg.manifest.runtime==='capability'&&mock?{capability:mock.capability}:{})});
   if(pkg.manifest.state)memory=result.state;
@@ -148,7 +152,7 @@ async function dev(path,options){
   return {outputs:result.outputs,...(result.logs?{logs:result.logs}:{}),...(calls.length?{standIns:calls}:{}),...(result.state!==undefined?{state:result.state}:{})};
  };
  const media=async url=>{
-  const made=answered?.host.file(url)||mock?.file(url);if(made)return made;
+  const made=pickedMedia(url)||answered?.host.file(url)||mock?.file(url);if(made)return made;
   let mocks={};try{mocks=JSON.parse(mocksText||'{}');}catch{}
   const local=answered?.files?.[url]??mocks.files?.[url];if(typeof local!=='string')return null;
   const full=resolve(path,local);if(!full.startsWith(path+sep))return null;
@@ -159,7 +163,7 @@ async function dev(path,options){
   ?{fileName:`${pkg.manifest.id}-${pkg.manifest.version}${MODULE_BUNDLE_SUFFIX}`,source:JSON.stringify(createModuleBundle(pkg,moduleFiles.get(pkg)))}
   :{fileName:`${pkg.manifest.id}-${pkg.manifest.version}.stillmade.json`,source:JSON.stringify(pkg)};
  const link=live?{origin:liveSite(site),key:randomBytes(24).toString('base64url')}:undefined;
- const server=await startDevServer({folder:path,port,build,load,run,media,live:link,bundle});
+ const server=await startDevServer({folder:path,port,build,load,run,media,pick,live:link,bundle});
  const liveUrl=link&&`${link.origin}/create/import?live=${encodeURIComponent(`${server.url}/__live/${link.key}`)}`;
  return {dev:server.url,folder:path,...(build?{build}:{}),...(liveUrl?{live:liveUrl}:{}),close:server.close};
 }
@@ -205,7 +209,11 @@ export async function main(rawArgs) {
     if(args.length<2)throw Object.assign(new Error('Name the folder to create: stillmade-block create my-block [template]'),{code:'USAGE'});
     const template=templateNamed(extra),files=await template.files({folder:path});
     // Every new Block starts with a feature map (one entry from its name and description) for the builder to rewrite as it grows.
-    {const created=JSON.parse(files['stillmade.block.json']);if(!created.features&&!created.stages){created.features=blockFeatures(created).map(({source,...feature})=>feature);files['stillmade.block.json']=`${JSON.stringify(created,null,2)}\n`;}}
+    {const created=JSON.parse(files['stillmade.block.json']);if(!created.features&&!created.stages){created.features=blockFeatures(created).map(({source,...feature})=>feature);files['stillmade.block.json']=`${JSON.stringify(created,null,2)}\n`;}
+     // The new Block is named for its folder, never the example it started from (November 1, 2026: a no-context agent's
+     // social-media-clip-maker kept the id example.poster-from-idea).
+     const slug=basename(path).toLowerCase().replace(/[^a-z0-9]+/g,'-').replace(/^[^a-z]+|-+$/g,'').slice(0,60);
+     if(!created.stages&&typeof created.id==='string'&&created.id.startsWith('example.')&&slug){created.id=`creator.${slug}`;files['stillmade.block.json']=`${JSON.stringify(created,null,2)}\n`;}}
     // Editors pick up the generated types for the view, src/run.js and module code.
     files['stillmade-env.d.ts']=blockTypeDeclarations(JSON.parse(files['stillmade.block.json']));
     files['jsconfig.json']=`${JSON.stringify({compilerOptions:{target:'ES2022',module:'ESNext',moduleResolution:'Bundler',lib:['ES2022','DOM'],jsx:'react-jsx',checkJs:false},include:['src','module','stillmade-env.d.ts']},null,2)}\n`;
@@ -295,14 +303,14 @@ export async function main(rawArgs) {
         if(!scan.passed)throw Object.assign(new Error(`${dependency.manifest.name}: Static validation failed`),{report:scan});
       }
       const output=jsonOutput(extra,`${pkg.id}-${pkg.version}.stillmade.json`);
-      await writeFile(output,JSON.stringify(pkg,null,2),{flag:'wx'});
+      await writeFile(output,JSON.stringify(pkg,null,2),{flag:packFlag(extra)});
       return {file:output,digest:await digest(pkg),tests:0,...review,message:'Project Type source packaged without execution. In StillMade, review every embedded hosted Block in StillMade (including ComfyUI backend fixtures and samples), then confirm the import after local admission checks. The connected workflow has not run.'};
     }
     const report = await testProjectType(pkg);
     if (!report.passed) throw Object.assign(new Error('Project Type validation or execution checks need attention'), { report:{...report,...(hosted ? {reviewRequired:true,liveVerified:false} : {})} });
     if (command === 'test') return report;
     const output = jsonOutput(extra,`${pkg.id}-${pkg.version}.stillmade.json`);
-    await writeFile(output, JSON.stringify(pkg, null, 2), { flag: 'wx' });
+    await writeFile(output, JSON.stringify(pkg, null, 2), { flag: packFlag(extra) });
     return { file: output, digest: report.digest, tests: (pkg.packages || []).reduce((count,dependency)=>count+dependency.tests.length,0), workflowComplete:report.workflowComplete, workflowStatus:report.workflowStatus };
   }
   // permissions: what the Block can do in plain words, and what its source uses that
@@ -330,7 +338,7 @@ export async function main(rawArgs) {
     const report=await admitLocalPackage(pkg,{files:moduleFiles.get(pkg),moduleExecution:true});if(!report.passed)throw Object.assign(new Error('Portable admission failed'),{report});
     const output=resolve(extra||`${pkg.manifest.id}-${pkg.manifest.version}.stillmade-block`);
     if(!output.endsWith('.stillmade-block'))throw new Error('Canonical output must end in .stillmade-block');
-    await writeFile(output,writePortableArchive(pkg,archiveCodec()),{flag:'wx'});return {file:output,digest:report.digest,tests:hosted?0:pkg.tests.length,format:pkg.portable.format,admission:report,repositoryEvidence:evidence,...(hosted?{fixtureContracts:pkg.tests.length,execution:'not-run',liveVerified:false,reviewRequired:true}:{})};
+    await writeFile(output,writePortableArchive(pkg,archiveCodec()),{flag:packFlag(extra)});return {file:output,digest:report.digest,tests:hosted?0:pkg.tests.length,format:pkg.portable.format,admission:report,repositoryEvidence:evidence,...(hosted?{fixtureContracts:pkg.tests.length,execution:'not-run',liveVerified:false,reviewRequired:true}:{})};
    }
   }
   const advice=command !== 'preview'?appearanceAdvice(pkg.view):null;
@@ -367,14 +375,14 @@ export async function main(rawArgs) {
     const report=await admitLocalPackage(pkg);if(!report.passed)throw Object.assign(new Error('Desktop source admission failed'),{report});
     if(command==='test')return report;
     const output=jsonOutput(extra,`${pkg.manifest.id}-${pkg.manifest.version}.stillmade.json`);
-    await writeFile(output,JSON.stringify(pkg,null,2),{flag:'wx'});
+    await writeFile(output,JSON.stringify(pkg,null,2),{flag:packFlag(extra)});
     return {file:output,digest:report.digest,tests:0,fixtureContracts:pkg.tests.length,execution:'not-run',liveVerified:false,reviewRequired:true,admission:report,message:'Source packaged without native execution. Run and review the declared action through its approved StillMade Desktop adapter.'};
   }
   if(command === 'pack' && ['comfyui','capability'].includes(pkg.manifest.runtime)) {
     const scan=scanPackage(pkg);
     if(!scan.passed)throw Object.assign(new Error('Static validation failed'),{report:scan});
     const output=jsonOutput(extra,`${pkg.manifest.id}-${pkg.manifest.version}.stillmade.json`);
-    await writeFile(output,JSON.stringify(pkg,null,2),{flag:'wx'});
+    await writeFile(output,JSON.stringify(pkg,null,2),{flag:packFlag(extra)});
     return {file:output,digest:await digest(pkg),tests:0,reviewRequired:true,...(pkg.manifest.runtime==='capability'?{liveVerified:false}:{}),message:pkg.manifest.runtime==='capability'?'Source packaged without provider execution. Import into StillMade, choose a model and payment method, and approve the fixtures and sample before confirming installation.':'Source packaged. Import into StillMade to run all fixtures and preview on your connected ComfyUI backend before confirming installation.'};
   }
   const mock=['module','capability'].includes(pkg.manifest.runtime)?await standIns(path,pkg,mockRequested):null,hostFor=await fixtureStandIns(path,pkg),own=[];
@@ -394,13 +402,16 @@ export async function main(rawArgs) {
   if (hasDigestFiles(pkg)) {
     const files=moduleFiles.get(pkg),output=resolve(extra || `${pkg.manifest.id}-${pkg.manifest.version}${MODULE_BUNDLE_SUFFIX}`);
     if(!output.endsWith(MODULE_BUNDLE_SUFFIX))throw new Error(`Module output must end in ${MODULE_BUNDLE_SUFFIX}`);
-    await writeFile(output,JSON.stringify(createModuleBundle(pkg,files)),{flag:'wx'});
+    await writeFile(output,JSON.stringify(createModuleBundle(pkg,files)),{flag:packFlag(extra)});
     return {file:output,digest:report.digest,tests:report.results.length,files:Object.keys(pkg.module?.files||{}).length+Object.keys(pkg.view?.files?.files||{}).length,...standInNote(mock,own),message:'Import this bundle in StillMade (Create, then Import). StillMade checks every file digest and uploads the files once before saving the Block.'};
   }
   const output = jsonOutput(extra,`${pkg.manifest.id}-${pkg.manifest.version}.stillmade.json`);
-  await writeFile(output, JSON.stringify(pkg, null, 2), { flag: 'wx' });
+  await writeFile(output, JSON.stringify(pkg, null, 2), { flag: packFlag(extra) });
   return { file: output, digest: report.digest, tests: report.results.length };
 }
+// pack replaces the file it wrote before under its own name, so packing again after a fix just works; an output path the
+// person names is never overwritten (November 1, 2026: a no-context agent's second pack failed with EEXIST).
+function packFlag(output){return output?'wx':'w';}
 // How many fixtures admission ran and passed, for the ready and gate reports.
 function fixtureCounts(pkg,admission){
  const rows=(admission.results||[]).filter(row=>/ contract test: /.test(row.name)),failed=rows.filter(row=>!row.passed);