Index: bgrd.c
==================================================================
--- bgrd.c
+++ bgrd.c
@@ -1,126 +1,127 @@
 /* [ʞ] bgrd.c
  *  ~ lexi hale <lexi@hale.su>
  *  $ cc -Ofast bgrd.c -lutil -obgrd
  *  © affero general public license 3.0
 
- * i am angry beyond words that this program had to
- * be written
+ * i am  angry beyond words  that this program had  to be
+ * written
  *
- * bgrd "background read" is a tool for launching an 
- * application and retrieving the first line of output.
- * this is a nontrivial task for a number of reasons,
- * all of which are incredibly stupid, however, most
+ * bgrd  "background read"  is  a tool  for launching  an
+ * application and  retrieving the first line  of output.
+ * this is  a nontrivial  task for  a number  of reasons,
+ * all  of which  are  incredibly  stupid, however,  most
  * saliently: buffered io.
  *
- * the suckmore web browser `surf` has an option '-x'
- * which is intended to print the X window id of the
- * window it opens, so it can be captured and used in
+ * the  suckmore web  browser `surf`  has an  option '-x'
+ * which  is intended  to print  the X  window id  of the
+ * window it  opens, so  it can be  captured and  used in
  * scripts. so far so good.
  *
- * except unix has two distinctly different concepts
- * of IO. there's POSIX IO, and then there's libc IO.
+ * except unix  has two distinctly different  concepts of
+ * IO. there's POSIX IO, and then there's libc IO.
  *
- * POSIX IO uses the shit in <fcntl.h> and <unistd.h>;
- * syscalls like read(2), write(2), and pipe(2) - the
- * good, simple shit God made unix for. this is really
- * bare-metal; these are basically C wrappers over
- * kernel syscalls. POSIX IO uses plain old ints as
- * file descriptors, and it doesn't fuck around. when
- * you say "write," god dammit, it WRITES.
+ * POSIX IO  uses the  shit in <fcntl.h>  and <unistd.h>;
+ * syscalls  like read(2),  write(2), and  pipe(2) -  the
+ * good, simple  shit God made  unix for. this  is really
+ * bare-metal; these are basically C wrappers over kernel
+ * syscalls.  POSIX  IO  uses  plain  old  ints  as  file
+ * descriptors, and it doesn't  fuck around. when you say
+ * "write," god dammit, it WRITES.
  *
- * libc is a very different beast. libc has opinions.
- * libc has abstractions. libc has its own entire
- * goddamn DSL by which to specify format strings,
- * because apparently someone felt called to reinvent
- * FORTRAN except worse. printf(), you know, the first
- * function they ever teach you in C 101? (more like CS
- * 403 these days, but aghhh) it's actually a heinously
+ * libc  is a  very different  beast. libc  has opinions.
+ * libc has abstractions. libc has its own entire goddamn
+ * DSL  by  which  to  specify  format  strings,  because
+ * apparently  someone felt  called  to reinvent  FORTRAN
+ * except worse.  printf(), you know, the  first function
+ * they  ever teach  you  in  C 101?  (more  like CS  403
+ * these  days,  but  aghhh) it's  actually  a  heinously
  * complicated, dangerous, slow, insecure mess that drags
- * a ridiculous amount of background bullshit into the
+ * a ridiculous  amount of  background bullshit  into the
  * frame. such as BUFFERING.
  *
- * libc, you see, is too good to just wrap write() and
- * read(). no, it also has to decide when to SEND them.
- * this is responsible for that behavior every c coder
- * trips over eventually - you know the one, where if
- * you don't end your format string in '\n' it isn't
- * printed, sometimes even if the program exits. this
- * is not actually a POSIX thing; it's a libc thing.
+ * libc, you  see, is too  good to just wrap  write() and
+ * read(). no, it  also has to decide when  to SEND them.
+ * this is  responsible for  that behavior every  c coder
+ * trips over eventually - you know the one, where if you
+ * don't end your format string in '\n' it isn't printed,
+ * sometimes  even  if the  program  exits.  this is  not
+ * actually a POSIX thing; it's a libc thing.
  *
  * libc has a couple different kinds of buffering tactics
- * (set with setvbuf(), a function nobody seems to know
- * exists) that it uses in different circumstances.
- * the printf \n gotcha behavior is what's known as
- * "line buffering." however, because libc thinks it's
- * fucking smart or something, it's not content to just
- * pick one predictable behavior and stick to it. oh no.
+ * (set with  setvbuf(), a function nobody  seems to know
+ * exists) that  it uses in different  circumstances. the
+ * printf  \n gotcha  behavior is  what's known  as "line
+ * buffering." however, because  libc thinks it's fucking
+ * smart or something, it's not  content to just pick one
+ * predictable behavior and stick to it. oh no.
  *
- * ever noticed how programs can seem to tell whether
- * they're connected to a terminal (and thus can output
- * all those fancy ansi formatting codes), or whether
- * you're redirecting their stdout to a file? that's 
- * because there's more than one kind of pipe. the kind
+ * ever  noticed how  programs can  seem to  tell whether
+ * they're connected  to a terminal (and  thus can output
+ * all  those fancy  ansi formatting  codes), or  whether
+ * you're  redirecting their  stdout  to  a file?  that's
+ * because there's more  than one kind of  pipe. the kind
  * you create with pipe(2) - and the kind you create with
  * openpty(2).
  *
- * a pty is, essentially, a kind of pipe that carries
- * extra information around, the information you access
+ * a pty  is, essentially,  a kind  of pipe  that carries
+ * extra information  around, the information  you access
  * via ioctl and termios. it's designed to imitate a TTY,
- * so that a shell can create one, aim a process at it,
- * and then that process can draw TUIs and shit on it.
- * and some programs are designed to behave differently
- * depending on whether they're hooked up to a pipe or a
+ * so that a  shell can create one, aim a  process at it,
+ * and then  that process can  draw TUIs and shit  on it.
+ * and some  programs are designed to  behave differently
+ * depending on whether they're hooked  up to a pipe or a
  * pty.
  *
  * libc, tragically, is among them.
  *
- * if libc notices it's hooked up to a pipe instead of a pty,
- * it will change its default buffering strategy. newlines
- * will suddenly cease flushing stdout, and libc will
- * only print its buffer in one of two circumstances: the
- * buffer is filled up, or the program exits.
+ * if libc notices it's hooked up  to a pipe instead of a
+ * pty, it  will change  its default  buffering strategy.
+ * newlines  will  suddenly  cease flushing  stdout,  and
+ * libc  will  only  print  its  buffer  in  one  of  two
+ * circumstances: the buffer is filled up, or the program
+ * exits.
  *
- * this is a problem if you are, say, trying to output a
- * handle that scripts can use to control the running
+ * this is a problem if you  are, say, trying to output a
+ * handle  that scripts  can use  to control  the running
  * program.
  *
- * the `surf` developers had a couple of options. they
- * could have simply broken out the POSIX headers and
- * sent the X id to stdout with a call to write(2), the
- * correct thing to do. they could have thrown in a call
- * to setvbuf(3) to explicitly pick a buffering strategy
- * compatible with their usecase, the sensibly wrong
+ * the `surf`  developers had  a couple of  options. they
+ * could  have simply  broken out  the POSIX  headers and
+ * sent the X  id to stdout with a call  to write(2), the
+ * correct thing to do. they  could have thrown in a call
+ * to setvbuf(3) to explicitly  pick a buffering strategy
+ * compatible  with  their  usecase, the  sensibly  wrong
  * thing to do. they could have explicitly flushed stdout
- * after printf(3)'ing to it, the dumb and error-pront
+ * after printf(3)'ing  to it,  the dumb  and error-pront
  * thing to do.
  *
  * instead, they did *nothing.*
  *
- * so if you run `surf -x` from a terminal, great!
- * you'll see it print the x window id first thing.
- * you'll then try to capture it via any number of
- * increasing desperate means, all of which will fail
- * hilariously. finally, you'll spend four goddamn hours
- * after midnight reading source code and manpages and
- * frantically googling around and digging up unix lore
- * and finally, FINALLY figure out what the batshit FUCK
- * is going on, and write this goddamn utility to hack
+ * so  if  you run  `surf  -x`  from a  terminal,  great!
+ * you'll  see it  print  the x  window  id first  thing.
+ * you'll  then  try to  capture  it  via any  number  of
+ * increasing  desperate means,  all of  which will  fail
+ * hilariously. finally, you'll  spend four goddamn hours
+ * after midnight  reading source  code and  manpages and
+ * frantically googling  around and digging up  unix lore
+ * and finally, FINALLY figure  out what the batshit FUCK
+ * is going  on, and write  this goddamn utility  to hack
  * around the suckmore crowd's suckitude.
  *
  * so i figured i'd save you some time.
  *
- * i am probably going to submit a PR eventually because
+ * i am probably going to  submit a PR eventually because
  * holy hell this is just so monumentally bozotic.
  *
- * in the mean time, you can use this extremely
- * no-bullshit wrapper by running `set surfwin (bgrd
- * (which surf) surf -x <params>` or whatever the bash
- * equivalent is and it will immediately launch surf in
- * the background, printing the X window and exiting
- * as soon as it hits a newline. it should be adaptable
- * to similar scenarios if you find yourself dealing with
+ * in  the   mean  time,  you  can   use  this  extremely
+ * no-bullshit  wrapper  by  running `set  surfwin  (bgrd
+ * (which surf)  surf -x  <params>` or whatever  the bash
+ * equivalent is  and it will immediately  launch surf in
+ * the background,  printing the X window  and exiting as
+ * soon as it  hits a newline. it should  be adaptable to
+ * similar scenarios  if you  find yourself  dealing with
  * similarly broken software tho.
  *
  * in conclusion, read lenin. */
 
 #include <stdio.h>

ADDED   smake.c
Index: smake.c
==================================================================
--- smake.c
+++ smake.c
@@ -0,0 +1,193 @@
+/* [ʞ] smake.c <c.hale.su/lexi/util>
+ *  ~ lexi hale <lexi@hale.su>
+ *  $ cc -Ofast smake.c -osmake
+ *  © affero general public license
+
+        	    * I N C O M P L E T E *
+			| basic functionality is still |
+			|  heavily  under development  |
+
+ * a replacement  for sassc  --watch, smake  maintains an
+ * in-memory  dependency graph  for  the specified  files
+ * and  automatically re-compiles  them  when  they or  a
+ * dependency of theirs changes
+
+ TODO add switch to generate makefile from constructed
+      graph and exit */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+enum       e { ok, badname, nofile };
+enum    kind { css, sass, scss, bad };
+typedef enum { false, true } bool;
+
+#define corebufsz 1024
+char corebuf[corebufsz];
+void* extbuf, * bufptr;
+size_t run = 0;
+#define max(a,b) (a > b ? a : b)
+
+void* alloc(size_t sz) {
+	if((bufptr + sz) < ((void*)corebuf + corebufsz)) goto mkptr;
+	else {
+		if (run == 0) {
+			run = corebufsz;
+			extbuf = malloc(run);
+			bufptr = extbuf + sz;
+			return extbuf;
+		} else {
+			if ((bufptr + sz) < (extbuf + run)) goto mkptr;
+			else {
+				run += max(512, sz+128);
+				size_t rsz = bufptr-extbuf;
+				extbuf = realloc(extbuf, run);
+				bufptr = extbuf + rsz + sz;
+				return bufptr - sz;
+			}
+		}
+	}
+	// this point should never be reached
+	mkptr: {
+		void* ret = bufptr;
+		bufptr += sz;
+		return ret;
+	}
+}
+
+
+
+struct file {
+	char* src;
+	char* out;
+	enum kind kind;
+	struct dep* deplink;
+};
+
+struct dep { struct file* f; struct dep* nextdep; };
+
+void readfile(struct file* f, char* src) {
+	f->src = src;
+
+	int fd = open(src, O_RDONLY);
+	int sz = lseek(fd,0,SEEK_END); lseek(fd,0,SEEK_SET);
+	char* file = mmap(0,sz,PROT_READ,MAP_PRIVATE,fd,0);
+	close(fd);
+
+	char namebuf[256];
+	char* namecur = namebuf;
+	char* cur = file;
+
+	char strqt = 0;
+
+read_start:
+	if (*cur == 0) goto read_done;
+	if (*cur == '"')  { ++ cur; strqt = '"';  goto read_string; }
+	if (*cur == '\'') { ++ cur; strqt = '\''; goto read_string; }
+	if (*cur == '(')  { ++ cur; strqt = ')';  goto read_string; }
+	if (*cur == '[')  { ++ cur; strqt = ']';  goto read_string; }
+	if (*cur == '/') {
+		switch(cur[1]) {
+			case '/': goto skip_line;
+			case '*': cur += 2; goto read_ml_comment;
+			case   0: goto read_done;
+		}
+		++cur; goto read_start;
+	}
+	if (*cur == '@') {
+		if (strncmp(cur+1, "import", 6) == 0) {
+			cur += 7; goto read_import;
+		}
+	}
+	++cur; goto read_start;
+
+read_import:
+	if (*cur == ' ' || *cur == '\t' || *cur == '\n') {
+		++cur; goto read_import;
+	} else if (*cur == 'u' && cur[1] == 'r' && cur[2] == 'l') {
+		strqt=')'; goto read_string;
+	} else if (*cur == '"' || *cur=='\'') {
+		strqt=*cur;
+		while(*++cur != strqt) {
+			if (*cur == '\\' && cur[1] == strqt) {
+				*namecur++=strqt; cur += 2;
+				// FIXME support other escapes
+			} else {
+				*namecur++=*cur;
+			}
+		}
+		*namecur = 0;
+		printf("found import to %s;\n", namebuf);
+		namecur = namebuf;
+	}
+	++cur; goto read_start;
+
+read_string:
+	if (*cur == 0) goto read_done; //unterminated string!?
+	if (*cur++ == strqt) goto read_start;
+	goto read_string;
+
+read_ml_comment:
+	if (*cur == 0) goto read_done; //unterminated comment!
+	if (*cur == '*' && cur[1] == '/') {
+		cur += 2;
+		goto read_start;
+	}
+	++cur; goto read_ml_comment;
+
+skip_line:
+	if (*cur == 0) goto read_done;
+	if (*cur++ == '\n') goto read_start;
+	goto skip_line;
+
+read_done:
+
+	munmap(file,sz);
+}
+
+enum e parsename(struct file* f) {
+	char* ext = NULL;
+	char* path = f->src;
+	
+	while(*path++!=0) {
+		if(*path == '.') ext = path + 1;
+	}
+
+	
+	if(ext == NULL) return badname;
+
+	// quickly determine file type
+	if        (ext[0] == 's'
+			&& ext[2] == 's'
+			&& ext[3] == 's') {
+		if      (ext[1] == 'c') f -> kind = scss;
+		else if (ext[1] == 'a') f -> kind = sass;
+		else                    f -> kind = bad;
+	} else if (ext[0] == 'c'
+			&& ext[1] == 's'
+			&& ext[2] == 's' )  f -> kind = css;
+	else                        f -> kind = bad;
+
+	if(f -> kind == sass || f -> kind == scss) {
+		size_t sz = (ext - f->src);
+		f->out = alloc(sz + 4);
+		strncpy(f->out, f->src, sz);
+		f->out[sz+0] = 'c';
+		f->out[sz+1] = 's';
+		f->out[sz+2] = 's';
+		f->out[sz+3] = 0;
+	} else f -> out = f -> src;
+
+	printf("src %s; dst %s; ext %s;\n", f->src,f->out,ext);
+}
+
+int main(int argc, char** argv) {
+	bufptr = corebuf;
+	struct file top;
+	readfile(&top, argv[1]);
+	parsename(&top);
+}

ADDED   xpriv.c
Index: xpriv.c
==================================================================
--- xpriv.c
+++ xpriv.c
@@ -0,0 +1,341 @@
+/* [ʞ] xpriv.c <c.hale.su/lexi/util>
+ *  ~ lexi hale <lexi@hale.su>
+ *  $ cc -Ofast xpriv.c -lrt -lutil -lX11 -oxpriv
+ *  © affero general public license
+
+ * xpriv.c is a tool for a very specific use case i have.
+ * for security's  sake, i  don't tie my  ssh keys  to my
+ * login session.  when i intend  to use them, i  spawn a
+ * special terminal  and load the keys  into memory, then
+ * exit that terminal when  i'm done using them. however,
+ * i often lose  track of or accidentally  kill that win-
+ * dow,  despite  adding  a  visual cue  to  its  prompt.
+ * safekill.c was one half of  my attempt to address this
+ * problem; this is the other.
+ *
+ * xpriv performs several different tasks to accomplish a
+ * single  purpose: i  can  hit a  single keystroke  that
+ * will either  conjure up  a new privileged  session, or
+ * switch to one  that's already active if  it exists. it
+ * does this  by first  checking for  the existence  of a
+ * shared  memory  segment. if  it  doesn't  find it,  it
+ * starts  a  new  session;  if it  *does*  find  it,  it
+ * retrieves the  X11 window  ID from that  shared memory
+ * and sends  a _NET_ACTIVE_WINDOW client message  to the
+ * root X window. the  window manager interprets message,
+ * activating the window.
+ *
+ * the  flag -k  can also  be passed,  in which  case the
+ * utility instructs the running process to liquidate its
+ * subprocesses and exit itself.
+ *
+ * if the shared  memory does not exist,  xpriv creates a
+ * new instance  of urxvt. this  instance is told  to run
+ * the command  “xpriv -a”  instead of the  user’s normal
+ * shell. the -a flag instructs xpriv to get the terminal
+ * window’s  ID from  the $WINDOWID  environment variable
+ * which urxvt  sets. after this, a  ssh-agent process is
+ * launched. spriv waits until it has opened a socket and
+ * then runs ssh-add without parameters to add the user's
+ * default keys to the session.
+ *
+ * xpriv  does  its  best   to  clean  up  after  itself,
+ * killing all sensitive processes and their children and
+ * removing the  shmem segment  when it  is no  longer in
+ * use, even if exits somewhat abnormally. if you have to
+ * kill -9 xpriv  at any point tho, you can  make it work
+ * again (on linux) with
+ *   rm /dev/shm/k.xpriv:(xpriv binary basename)
+ *
+ * you can have multiple xpriv sessions by creating soft-
+ * links to the binary with a different name for each.
+
+ TODO send signal to urxvtd directly instead of launching
+      urxvtc as a separate process
+	  
+ TODO make shell & commands performed configurable, with
+      flags to control or supplant ssh-agent 
+
+ TODO add a randomizer call that works on BSD
+ 
+ TODO document flags
+ 
+ TODO implement/remove lock flag
+
+ TODO add flag to bring window to current desktop */
+ 
+
+#include <pwd.h>
+#include <pty.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <X11/Xlib.h>
+#include <errno.h>
+#include <sys/random.h> //TODO bsd compat
+
+#define shmem_prefix "/k.xpriv:"
+
+typedef enum { false, true } bool;
+enum mode { mode_usage, mode_go, mode_register,
+	mode_kill, mode_lock };
+
+enum res { ok, fail_parse, fail_arg, fail_opt, fail_shm,
+               fail_mem, fail_pty, fail_nop, fail_win,
+               fail_wid, fail_x11};
+enum res bad(enum res code) {
+	if (code == ok) return ok;
+
+	write(1,"\e[1m|e|\e[0m ",12);
+	const char* msg; uint8_t len;
+	switch(code) {
+		#define say(x) { msg = (x "\n"); len = (sizeof x) + 1; break; }
+		case fail_parse: say("could not parse command-line options; pass -u for usage");
+		case fail_arg  : say("invalid argument provided");
+		case fail_opt  : say("no such option");
+		case fail_shm  : say("instance already running");
+		case fail_mem  : say("could not map memory");
+		case fail_pty  : say("could not alloc pty");
+		case fail_nop  : say("no instance running");
+		case fail_win  : say("cannot open display");
+		case fail_wid  : say("WINDOWID not defined");
+		case fail_x11  : say("X server refuses to handle request");
+		#undef say
+	}
+	write(1, msg, len);
+	return code;
+}
+
+struct signal {
+	Window    wid;
+	pid_t     pid;
+	pid_t     agent;
+	enum mode op;
+}*global;
+
+char* itoa(unsigned long i, char* buf, size_t bufsz) {
+	char* cur = buf + bufsz;
+	while (cur >= buf) {
+		*--cur='0' + i % 10;
+		if (i < 10) break; else i /= 10;
+	}
+	return cur;
+}
+
+bool run;
+
+struct termios initial_state;
+
+void sigusr(int a) { if (global -> op == mode_kill) run = false; }
+void sigterm(int a) { run = false; }
+
+enum res register_window(const char* id, bool weak) {
+	// the id field denotes the path to the shared memory
+	// in use, and allows the user to have multiple
+	// contexts by creating aliases to the binary
+	int fd = shm_open(id, O_CREAT | O_EXCL | O_RDWR, 0600);
+	ftruncate(fd, sizeof(struct signal));
+	if (fd == -1) return fail_shm;
+	
+	struct signal* s = mmap(0, sizeof(struct signal),
+			PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if(s == MAP_FAILED) return fail_mem;
+	else global = s;
+
+	Display* xdpy = XOpenDisplay(NULL);
+	Atom xvital;
+
+	/* x11 */ {
+		if (xdpy == NULL) return fail_win;
+		Window win;
+		const char* winid_s;
+		if (!(winid_s = getenv("WINDOWID"))) return fail_wid;
+		win=(Window)strtol(winid_s,NULL,10);
+		if(weak == false) xvital = XInternAtom(xdpy,"_k_vital",false);
+		s -> wid = win;
+	}
+
+	pid_t child;
+	if(child = fork()) {
+		s -> pid = child;
+		sigset_t mask, oldmask;
+		sigemptyset(&mask);
+		sigaddset(&mask, SIGUSR1);
+		sigprocmask(SIG_BLOCK, &mask, &oldmask);
+
+		signal(SIGUSR1, sigusr);
+		signal(SIGTERM, sigterm);
+		signal(SIGCHLD, sigterm);
+		signal(SIGHUP, sigterm);
+
+		run = true;
+		while(run == true) {
+			sigsuspend(&oldmask);
+		}
+
+		if(s -> op == mode_kill) {
+			kill(s -> pid, SIGTERM);
+		}
+		kill(s -> agent, SIGTERM);
+		sigprocmask(SIG_BLOCK, &mask, NULL);
+		shm_unlink(id);
+		if (!weak) {
+			XDeleteProperty(xdpy,s -> wid,xvital);
+			XSync(xdpy,false);
+		}
+		XCloseDisplay(xdpy);
+	} else {
+		// now we start ssh-agent and set the proper environment
+		// variables
+		pid_t ssha;
+
+		/* messy part */ {
+			const char* tmp; //tmpdir defined?
+			if (!(tmp = getenv("TMPDIR"))) tmp = "/tmp";
+			size_t tmpsz = strlen(tmp);
+			
+			char sockn[tmpsz + 1 + sizeof "ssh."
+				+ 11];
+			strcpy(sockn, tmp);
+			sockn[tmpsz] = '/';
+			strcpy(sockn+tmpsz+1,"ssh.");
+			
+			// first, gen a random identifier so we have the ability
+			// to know where the socket winds up
+			uint8_t* rndid = sockn+tmpsz+1+4;
+			getrandom(rndid, 11, 0);
+			
+			// assuming ascii…
+			for(uint8_t*i=rndid;i<rndid+11;++i) {
+				*i = '0' + (*i % (25 * 2 + 10));
+				if (*i > '9') *i += 7;
+				if (*i > 'Z') *i += ('a' - 'Z');
+			}
+
+			if (ssha = fork()) {
+				char pid_s_buf[16];
+				char* pid_s = itoa(ssha, pid_s_buf, sizeof(pid_s_buf));
+				while (access(sockn, F_OK));
+					// avoid nasty race condition
+				setenv("SSH_AGENT_PID", pid_s, true);
+				setenv("SSH_AUTH_SOCK", sockn, true);
+				s -> agent = ssha;
+			} else {
+				close(1); close(0);
+				execlp("ssh-agent","ssh-agent","-D", "-a",sockn,0);
+			}
+		}
+		
+		pid_t sad;
+		int p;
+		if (sad = fork()) {
+			int added;
+			waitpid(sad, &added, 0);
+			if (added == 0) {
+				if (weak == false) {
+					XChangeProperty(xdpy,s -> wid,xvital,xvital,8,PropModeReplace,"\01", 1);
+					XSync(xdpy,false);
+				}
+				write(1,"\033c",3);
+				execlp("fish","fish",NULL);
+			} else { return ok; }
+		} else {
+			execlp("ssh-add","ssh-add",NULL);
+		}
+	}
+
+	return ok; // this is kind of pointless but w/e
+}
+enum res kill_window(const char* id) {
+	int fd = shm_open(id, O_RDWR, 0600);
+	if (fd == -1) return fail_nop;
+
+	struct signal* s = mmap(0, sizeof(struct signal),
+			PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if(s == MAP_FAILED) return fail_mem;
+
+	s -> op = mode_kill;
+	kill(s -> pid, SIGUSR1);
+
+	return ok;
+}
+enum res activate_window(Window w) {
+	Display* dpy = XOpenDisplay(NULL);
+	XEvent ev;
+	long mask = SubstructureRedirectMask | SubstructureNotifyMask;
+	ev.xclient.type       = ClientMessage;
+	ev.xclient.serial     = 0;
+	ev.xclient.send_event = True;
+	ev.xclient.message_type = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
+	ev.xclient.display    = dpy;
+	ev.xclient.window     = w;
+	ev.xclient.format     = 32;
+	ev.xclient.data.l[0]  = 2;
+	ev.xclient.data.l[1]  = CurrentTime;
+	ev.xclient.data.l[2]  = 0;
+	
+	if(!XSendEvent(dpy, DefaultRootWindow(dpy), False, mask, &ev)) return fail_x11;
+
+	XSync(dpy,false);
+	return ok;
+}
+
+int main(int sz, char** argv) {
+	enum mode op = mode_go;
+	bool init_weak = false;
+
+	for(int i = 1; i<sz; ++i) {
+		char* v = argv[i];
+		if (*v != '-') return bad(fail_arg);
+		char* opt = v + 1;
+	read_opt:
+		switch(*opt) {
+			case 'a': op = mode_register; break;
+			case 'k': op = mode_kill; break;
+			case 'l': op = mode_lock; break;
+			case 'h': op = mode_usage; break;
+			case 'w': init_weak = true; break;
+			default: return bad(fail_opt);
+		}
+		if(opt[1] != 0) { ++opt; goto read_opt; }
+	}
+
+	size_t nsz;
+	const char* basename, *p;
+	for (p = argv[0]; *p!=0; ++p) {
+		if(*p == '/') basename = p + 1;
+	}
+	nsz = p - basename;
+	char shid[nsz + sizeof shmem_prefix + 0];
+	strncpy(shid,shmem_prefix,sizeof shmem_prefix);
+	strncpy(shid + sizeof shmem_prefix - 1, basename, nsz);
+
+	if (op == mode_go) {
+		int fd;
+		if ((fd = shm_open(shid, O_RDWR, 0600)) == -1) {
+			execlp("urxvtc", "urxvtc", "-bg", "[80]#4b0024",
+					"-e", argv[0], (init_weak?"-aw":"-a"), 0);
+		} else {
+			struct signal*s = mmap(0, sizeof(struct signal),
+					PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+			return bad(activate_window(s->wid));
+		}
+	} else if (op == mode_register)
+		return bad(register_window(shid,init_weak));
+	else if (op == mode_kill)
+		return bad(kill_window(shid));
+	else if (op == mode_usage) {
+		write(1,"\e[1musage:\e[0m ",15);
+		write(1, argv[0], strlen(argv[0]));
+		write(1, " [-aklw [arg]]\n",16);
+		return fail_parse;
+	}
+}
+