Construct a semidirect product in GAP I am trying to create the following group $G=(\operatorname{SL}_2(8) \times C_2 \times C_2) \rtimes C_3$ where the $C_3$ acts simultaneously: 
on $\operatorname{SL_2(8)}$ as the outer automorphism of order $3$
on $C_2\times C_2$ as the automorphism that permutes the three nonidentity elements 
I tried the following instructions: 
 gap> C:=CyclicGroup(2);
 gap> C:=DirectProduct(C,C);
 gap> G:=DirectProduct(SL(2,8),C);
 gap> A:=AutomorphismGroup(G);
 gap> I:=InnerAutomorphismsAutomorphismGroup(A);
 gap> B:=A/I;
 gap> S:=SylowSubgroup(B,3);
 gap> SemidirectProduct(S,G);

But sadly it gives me an error. I assume it is because of the quotient, but I do not know how I could "find" the correct $C_3$ action in $A$ without removing the inner automorphisms first. Is there a way of doing such a thing?
Edit: I get this error after the last line
 Error, usage: Image(<map>), Image(<map>,<elm>), Image(<map>,<coll>) called from
 Image( aut, PreImagesRepresentative( epi, i ) ) at /proc/cygdrive/C/gap4r8/lib/grppclat.gi:88 called from
 func( C[i] ) at /proc/cygdrive/C/gap4r8/lib/coll.gi:746 called from
 List( GeneratorsOfGroup( f ), function ( i )
  return Image( epi, Image( aut, PreImagesRepresentative( epi, i ) ) );
   end ) at /proc/cygdrive/C/gap4r8/lib/grppclat.gi:88 called from
 InducedAutomorphism( niso, i ) at /proc/cygdrive/C/gap4r8/lib/gprd.gi:1094      called from
 SemidirectProduct( G, IdentityMapping( G ), N ) at /proc/cygdrive/C/gap4r8/lib/gprd.gi:1071 called from
 ...  at line 15 of *stdin*
 you can 'quit;' to quit to outer loop, or
 you can 'return;' to continue

 A: What you are providing is a perfectly good description of the product as far as a textbook is concerned. Alas, GAP is really picky in that objects are not just "somehow" as you describe, but very exact. E.g. an automorphism of $G$ is not automatically an automorphism of $G\times H$ or of $G/N$. Typically this requires to attach suitable homomorphisms (which often are called ``natural'' or similar terms in a textbook). So in your case, I would create SL$_2(8)$ and $C_2\times C_2$ first, construct the automorphisms there, form the direct product and the corresponding automorphisms and so on.
This gives the following construction (there are shortcuts, it is deliberately detailled and thus boring). One obvious way to make it perform faster would be to represent both C and L by permutation groups so that the whole calculation can stay in the category of permutation groups.
First create $C_\times C_2$ and find an element of order 3 in the automorphism group.
gap> C:=CyclicGroup(2);
<pc group of size 2 with 1 generators>
gap> C:=DirectProduct(C,C);
<pc group of size 4 with 2 generators>
gap> au:=AutomorphismGroup(C);
<group with 4 generators>
gap> Size(au);
6
gap> s:=SylowSubgroup(au,3);
gap> a1:=GeneratorsOfGroup(s)[1];
[ f1, f2 ] -> [ f1*f2, f1 ]

Then do the same with SL$_2(8)$. We want an outer automorphism and do a random search (one could take a pre-image under a natural homomorphism... but its messy enough as is)
gap> L:=SL(2,8);
SL(2,8)
gap> au:=AutomorphismGroup(L);
<group of size 1512 with 3 generators>
gap> inn:=InnerAutomorphismsAutomorphismGroup(au);
<group of size 504 with 2 generators>
gap> Size(au)/Size(inn);
3
gap> repeat r:=Random(au);until not r in inn and Order(r)=3;
gap> a2:=r;
CompositionMapping([... very messy]

Now we form the direct product and embedding and projection maps and constructs the automorphisms of this direct product induced by the two automorphisms by looking what they do to the generators of either direct factor (and trivial on the other factor)
gap> d:=DirectProduct(C,L);
<group of size 2016 with 4 generators>
gap> e1:=Embedding(d,1);;
gap> e2:=Embedding(d,2);;
gap> p1:=Projection(d,1);;
gap> p2:=Projection(d,2);;
gap> gen1:=GeneratorsOfGroup(Image(e1));
[ DirectProductElement( [ f1, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ] ),
  DirectProductElement( [ f2, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ] ) ]
gap> gen2:=GeneratorsOfGroup(Image(e2));;
gap> img1:=List(gen1,x->Image(e1,Image(a1,Image(p1,x))));
[ DirectProductElement( [ f1*f2, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2),
    Z(2)^0 ] ] ] ), DirectProductElement( [ f1, [ [ Z(2)^0, 0*Z(2) ],
    [ 0*Z(2), Z(2)^0 ] ] ] ) ]
gap> au1:=GroupHomomorphismByImages(d,d,Concatenation(gen1,gen2),Concatenation(img1,gen2));
[ DirectProdu[... complicated]

gap> img2:=List(gen2,x->Image(e2,Image(a2,Image(p2,x))));;
gap> au2:=GroupHomomorphismByImages(d,d,Concatenation(gen1,gen2),Concatenation(gen1,img2));;
gap> Order(au1);
3
gap> Order(au2);
3

Both seem to be of right order. So now make a map from a new $C_3$ to the group generators by these two automorphisms that maps the generator to the product of the two automorphisms (as that is the action you want).
gap> z:=CyclicGroup(3);
gap> map:=GroupHomomorphismByImages(z,Group(au1,au2),[z.1],[au1*au2]);
[ f1 ] -> [...]

Finally we can form the semidirect product. GAP decided to represent it as a permutation group but it will have appropriate Embeddings and Projections that you can recover your original group.
gap> sdp:=SemidirectProduct(z,map,d);
<permutation group with 5 generators>
gap> Size(sdp);
6048

Uff! That was hard work. Now we know why the textbook is sloppy.
