@naanlang/naan 1.0.2 → 1.0.5

package/frameworks/node/apiserver.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2021 by Richard C. Zulch
+ * Copyright (c) 2017-2022 by Richard C. Zulch
  *
  */
 
@@ -36,6 +36,7 @@ closure MakeAPI(port, options, callback, local chroot, server) {
     server.psm = require("./psm_server.nlg").MakeServerPSM(server)
     server.root = chroot
     server.app = express()
+    server.guid = options.guid
     server.notifyq = []
     server.responseq = []
     server.projects = { }
@@ -99,8 +100,9 @@ closure MakeAPI(port, options, callback, local chroot, server) {
     // body parsing
     //
 
-    server.app.use(bodyParser.text({limit: "20mb"}))
-    server.app.use(bodyParser.raw({limit: "20mb"}))
+    server.app.use(bodyParser.json({limit: "5mb"}))
+    server.app.use(bodyParser.text({limit: "25mb"}))
+    server.app.use(bodyParser.raw({limit: "25mb"}))
 
     //
     // Express.js endpoints
@@ -108,8 +110,12 @@ closure MakeAPI(port, options, callback, local chroot, server) {
 
     server.app.use(function(req,res,next) {
         res.header("Access-Control-Allow-Origin", "*")
-        res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE")
-        next()
+        res.header("Access-Control-Allow-Methods", "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS")
+        res.header("Access-Control-Allow-Headers", "x-naanlang-api-guid")
+        if req.method == "OPTIONS"
+            res.sendStatus(200)
+        else
+            next()
     })
 
     server.app.use("", express.static(chroot))
@@ -121,15 +127,18 @@ closure MakeAPI(port, options, callback, local chroot, server) {
     //  "/"
 
     server.app.get("/", function(req, res) {
-        res.send("<u>NaanIDE API</u><br>\r\n"
+        res.send("<u>naan-server API</u><br>\r\n"
         "   /readfile?path=<i>filepath</i><br>\r\n"
         "   /status?timeout=<i>msec</i>&after=<i>stamp</i><br>\r\n")
     })
 
     //  "/readfile"
 
-    server.app.get("/readfile", closure(req, res) {
-        if not string(req.query.path)
+    server.app.get("/readfile", closure(req, res, local guid) {
+        guid = req.get("x-naanlang-api-guid")
+        if server.guid && guid != server.guid
+            res.status(403).send("unauthorized")
+        else if not string(req.query.path)
             res.status(400).send("Invalid filename")
         else if RegExp("^\\.\\.[/\\\\]|[/\\\\]\\.\\.$|[/\\\\]\\.\\.[/\\\\]").test(req.query.path)
             res.status(403).send("\"Parent path references forbidden\"")
@@ -156,7 +165,10 @@ closure MakeAPI(port, options, callback, local chroot, server) {
 
     //  "/status"
 
-    server.app.get("/status", closure(req,res, local timeoutms, after, responder) {
+    server.app.get("/status", closure(req, res, local guid, timeoutms, after, responder) {
+        guid = req.get("x-naanlang-api-guid")
+        if server.guid && guid != server.guid
+            res.status(403).send("unauthorized")
         timeoutms = toint(req.query.timeout)
         after = toint(req.query.after)
         if not integer(timeoutms) or timeoutms > 10000
@@ -187,8 +199,11 @@ closure MakeAPI(port, options, callback, local chroot, server) {
 
     //  "/psm"
 
-    server.app.all("/psm", closure(req, res) {
-        if !server.hostfs
+    server.app.all("/psm", closure(req, res, local guid) {
+        guid = req.get("x-naanlang-api-guid")
+        if server.guid && guid != server.guid && req.method !== "OPTIONS"
+            res.status(403).send("unauthorized")
+        else if !server.hostfs
             res.status(503).send("host filesystem not available")
         else
             server.hostfs.api(req, res)
@@ -227,7 +242,6 @@ closure MakeAPI(port, options, callback, local chroot, server) {
         server.ws = WebSocketServer(server)
         server.port = port
         callback(false, port, server)                                           // notify of success
-        debuglog("server open on port", port)
         result = server.psm.conns.NodeFS.connect("Host", "NideFS", list(""))    // ### this should go through resource tracker
         if result.0
             ErrorDebuglog(Error("can't access HostFS", result.0))
@@ -264,7 +278,7 @@ closure WebSocketServer(server, local websocks) {
     // Event handlers
 
     websocks.wss.on("connection", function(socket, request) {
-        websocks.conns.push(WesCon(websocks, socket, request))
+        websocks.conns.push(WesCon(server, websocks, socket, request))
     })
                 
     server.wss.on("error", function(error) {
@@ -303,7 +317,7 @@ closure WebSocketServer(server, local websocks) {
  *
  */
 
-closure WesCon(websocks, socket, request, local wescon) {
+closure WesCon(server, websocks, socket, request, local wescon) {
     wescon = new(object, this)
     wescon.socket = socket
     wescon.serverIDs = []
@@ -315,7 +329,9 @@ closure WesCon(websocks, socket, request, local wescon) {
     socket.on("message", function onmessage(text, local message, error) {
         try {
             message = new(js.g.JSON.parse(text))
-            if message.clientID && websocks.subsystems[message.serverID] {
+            if server.guid && message.guid != server.guid
+                error = Error("unauthorized")
+            else if message.clientID && websocks.subsystems[message.serverID] {
                 wescon.serverIDs.push(message.serverID)                     // ### track subsystems for closing
                 websocks.subsystems[message.serverID].wsReceive(message, wescon)
             }

package/frameworks/node/filesystem.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2021 by Richard C. Zulch
+ * Copyright (c) 2017-2022 by Richard C. Zulch
  *
  */
 
@@ -23,7 +23,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     if !rootpath
         return (list(Error("mandatory rootpath missing")))
     else if rootpath == ""
-        rootpath = js.g.process.cwd()                                       // NodeJS uses CWD for empty rootpath
+        rootpath = JSpath.sep
     files = new(object, this)
     files.rootpath = rootpath
     files.path = JSpath
@@ -54,24 +54,31 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     // Convert a path argument to a local path, returning a standard result tuple. If the path is
     // invalid this will report why. Otherwise this returns the correct localpath, which is the path
     // we use with the underlying API.
+    //     Win32 driver letters are annoying here. If the rootpath specifies a drive letter then the
+    // paths must match it. If the rootpath doesn't specify a drive letter then path can have any
+    // drive letter, or none.
     
     badCreatePathRegEx = RegExp("[:]|[/\\\\][/\\\\]|[/\\\\]$|(^|[/\\\\])[.][.]?$")
 
-    closure localPath(path, create, local pattern, testpath) {
+    files.localPath = closure localPath(path, create, local pattern, testpath, locroot) {
         if !path
             return (list(Error("filesystem path false")))
         else if !string(path)
             return (list(Error("filesystem path invalid:", typeof(path))))
+        if JSpath === JSpath.win32 {
+            locroot = JSpath.resolve(path, rootpath)                        // use path's drive letter if we don't have one
+            pattern = "\\:\\"                                               // unchanged and unique on win32
+        }
+        else {
+            locroot = rootpath
+            pattern = "/:/"                                                 // unchanged and unique on posix
+        }
         if JSpath.isAbsolute(path)
-            path = JSpath.resolve(path)                                     // puts C: in front of \abs\win\path
+            path = JSpath.resolve(locroot, path)                            // add drive letter to absolute path
         else
             path = JSpath.normalize(path)                                   // normalize for current platform
-        if JSpath === JSpath.win32
-            pattern = "\\:\\"                                               // unchanged and unique on win32
-        else
-            pattern = "/:/"                                                 // unchanged and unique on posix
-        if ((testpath = commonParents(path, rootpath)) != "")
-            list(false, JSpath.resolve(rootpath, path))                     // ### shouldn't be so lax on this test
+        if (commonParents(path, locroot) != "")
+            list(false, JSpath.resolve(locroot, path))
         else if ((testpath = JSpath.resolve(pattern, path)).indexOf(pattern.slice(0,-1)) < 0)
             list(Error("filesystem path reaches above root:", path))
         else if create && testpath.indexOf(pattern) < 0
@@ -79,7 +86,31 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         else if create && badCreatePathRegEx.test(path)
             list(Error("filesystem create path invalid", path))
         else
-            list(false, JSpath.resolve(rootpath, path))
+            list(false, JSpath.resolve(locroot, path))
+    }
+    
+    // folderPath
+    //
+    // Return a folder path for the specified folderID, relative to our root. If the folder path is
+    // not within our root then it is returned as an absolute path.
+    
+    files.folderPath = function folderPath(folderID, callback, local envID, path) {
+        if !callback
+            return (syncAdapter(folderPath, folderID))
+        envID = {
+            "HomeDir":      "HOME",
+            "TempDir":      "TMPDIR",
+            "PackageDir":   "npm_config_prefix"
+        }[folderID]
+        if envID {
+            path = js.g.process.env[envID]
+            if path.startsWith(rootpath)
+                path = path.slice(rootpath.length)                          // remove rootpath from beginning
+        }
+        if path
+            callback(false, path)
+        else
+            callback(Error("unknown folderID:", folderID))
     }
 
     // winDrives
@@ -273,11 +304,48 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                 callback(false, { md5: md5data })
         })
     }
-    
+       
+    // readlink
+    //
+    // Read the contents of a symbolic link.
+
+    files.readlink = closure readlink(path, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(readlink, path))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.readlink(localpath, function(err, linkString) {
+            if err
+                callback(Error("fs.readlink failed:", localpath, err))
+            else
+                callback(false, linkString)
+        })
+    }
+       
+    // symlink
+    //
+    // Create a symbolic link "path" that points to "target". No options are currently supported.
+
+    files.symlink = closure symlink(target, path, options, callback,
+        local error, localpath) {
+        if !callback
+            return (syncAdapter(symlink, target, path, options))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.symlink(target, localpath, function(err) {
+            if err
+                callback(Error("fs.symlink failed:", target, localpath, err))
+            else
+                callback(false, { ok: true })
+        })
+    }
+
     // delete
     //
     // Delete the file at the specified path, or a directory if the options dictionary includes:
-    //     recursive: true          -- "recursively" delete directory and children
+    //     recursive: true          -- recursively delete directory and children
 
     files.delete = closure delete(path, options, callback, local error, localpath) {
         if !callback
@@ -286,9 +354,9 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         if error
             return (asyncResult(callback, error))
         if options.recursive
-            fs.rmdir(localpath, function(err) {
+            fs.rm(localpath, { recursive: true, force: true }, function(err) {
                 if err
-                    callback(Error("fs.rmdir failed:", localpath, err))
+                    callback(Error("fs.rm failed:", localpath, err))
                 else
                     callback(false, { ok: true })
             })
@@ -303,15 +371,22 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
 
     // info
     //
-    //     Report info on a file or directory.
+    //     Report info on a file or directory. The options are:
+    //  {
+    //      follow:                             <boolean>                   // follow links
+    //  }
 
-    files.info = closure info(path, callback, local error, localpath) {
+    files.info = closure info(path, options, callback, local error, localpath, fsop) {
         if !callback
-            return (syncAdapter(info, path))
+            return (syncAdapter(info, path, options))
         `(error, localpath) = localPath(path)
         if error
             return (asyncResult(callback, error))
-        fs.lstat(localpath, function(err, stat, local data, info, nodetype) {
+        if options.follow
+            fsop = `stat
+        else
+            fsop = `lstat
+        fs[fsop](localpath, function(err, stat, local data, info, nodetype) {
             if err
                 return (callback(Error("fs.stat failed:", localpath, err)))
             info = {
@@ -336,9 +411,102 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         })
     }
 
+    // setInfo
+    //
+    //     Set selected info on a file or directory. The info dictionary has the same layout as that
+    // returned by files.info(), and every applicable key defined in the dictionary is set. To omit
+    // setting some of the information, remove its key from the info dictionary. The applicable keys
+    // are:
+    //  {
+    //      mtimeMs:                            <milliseconds>
+    //      mtime:                              <date>
+    //      nodejs_stat: {
+    //          mode:                           <number>
+    //          uid:                            <uid>
+    //          gid:                            <gid>
+    //          atimeMs:                        <milliseconds>
+    //          atime:                          <date>
+    //          mtimeMs:                        <milliseconds>
+    //          mtime:                          <date>
+    //      }
+    //  }
+    // If more than one timestamp exists of a certain type, the millisecond version is used. Some
+    // values are set together by the OS, like uid & guid, or mtime & atime. Specifying just one of
+    // these will cause setInfo to use the same value for both.
+
+    files.setInfo = closure setInfo(path, info, callback,
+        local error, localpath, mtime, atime, uid, gid) {
+        if !callback
+            return (syncAdapter(setInfo, path, info))
+        if !dictionary(info) && !xobject(info)
+            error = Error("setInfo: invalid argument:", typeof(info))
+        else
+            `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        atime = info.nodejs_stat.atimeMs/1000.0 || info.nodejs_stat.atime
+        mtime = info.mtimeMs/1000.0 || info.mtime
+        if !mtime
+            mtime = info.nodejs_stat.mtimeMs/1000.0 || info.nodejs_stat.mtime
+        if atime || mtime {
+            atime = atime || mtime
+            mtime = mtime || atime
+            `(error) = setTimes(path, atime, mtime)
+        }
+        if !error && info.nodejs_stat.mode
+            `(error) = setMode(path, info.nodejs_stat.mode)
+        uid = info.nodejs_stat.uid
+        gid = info.nodejs_stat.gid
+        if !error && (uid || gid) {
+            uid = uid || gid
+            gid = gid || uid
+            `(error) = setOwnerGroup(path, uid, gid)
+        }
+        if error
+            callback(Error("setInfo failed:", localpath, error))
+        else
+            callback(false, { ok: true})
+    }
+
+    // setOwnerGroup
+    //
+    //     Set owner/group on a file or directory.
+    
+    files.setOwnerGroup = closure setOwnerGroup(path, uid, gid, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(setOwnerGroup, path, uid, gid))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.chown(localpath, uid, gid, function(err, stat) {
+            if err
+                callback(Error("fs.chown failed:", localpath, err))
+            else
+                callback(false, { ok: true})
+        })
+    }
+
+    // setMode
+    //
+    //     Set mode bits on a file or directory.
+    
+    files.setMode = closure setMode(path, mode, callback, local error, localpath) {
+        if !callback
+            return (syncAdapter(setMode, path, mode))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        fs.chmod(localpath, mode, function(err, stat) {
+            if err
+                callback(Error("fs.chmod failed:", localpath, err))
+            else
+                callback(false, { ok: true})
+        })
+    }
+
     // setTimes
     //
-    //     Set timestamps on a file or directory.
+    //     Set timestamps on a file or directory. The timestamps can be dates or numeric seconds.
     
     files.setTimes = closure setTimes(path, atime, mtime, callback, local error, localpath) {
         if !callback
@@ -346,9 +514,6 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         `(error, localpath) = localPath(path)
         if error
             return (asyncResult(callback, error))
-        if !numeric(atime, mtime)
-            return (asyncResult(callback, Error("invalid arguments:", atime, mtime)))
-        localpath = JSpath.resolve(rootpath, localpath)
         fs.utimes(localpath, atime, mtime, function(err, stat) {
             if err
                 callback(Error("fs.utimes failed:", localpath, err))
@@ -375,7 +540,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                     if name {                                               // this record is fetchable
                         ++pending.active
                         filepath = JSpath.join(parentpath, name)
-                        files.info(filepath, function(error, info) {
+                        files.info(filepath, false, function(error, info) {
                             if error
                                 input[kdex].error = error                   // this record failed
                             else
@@ -398,7 +563,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
 
     // dirList
     //
-    // Return array of files in a directory if it exists. If options.head is true then this reads 
+    // Return array of files in a directory if it exists. If options.stat is true then this reads 
     // info for each file as well.
 
     files.dirList = closure dirList(path, options, callback, local error, localpath, output, nodelist, file) {
@@ -426,7 +591,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                 output.children.push({
                     name: file
                 })
-            if options.head
+            if options.stat
                 statfetch(output.children, localpath)                       // read all the info records
             callback(false, output)
         })
@@ -505,8 +670,10 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         // Recursively build the tree
 
         closure recurTree(localpath, depth, parent) {
-            if depthlimit && depth >= depthlimit
+            if depthlimit && depth >= depthlimit {
+                recurNext()
                 return
+            }
             ++pending.active
             fs.readdir(localpath, { }, function(err, nodes, local child, node, stat) {
                 if err.code == "ENOTDIR"
@@ -536,13 +703,21 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                             parent: child
                         }) } }
                 --pending.active
-                while queue.length > 0 && pending.active < 20 {
-                    node = queue.pop()
-                    recurTree(node.path, node.depth, node.parent) }
-                if pending.active == 0 && queue.length == 0
-                    pending.signal(list(false, root))
+                recurNext()
             })
         }
+        
+        // recurNext
+        //
+        // Pull more queued items and signal when done.
+        
+        function recurNext(local node) {
+            while queue.length > 0 && pending.active < 20 {
+                node = queue.pop()
+                recurTree(node.path, node.depth, node.parent) }
+            if pending.active == 0 && queue.length == 0
+                pending.signal(list(false, root))
+        }
 
         `(error, localpath) = localPath(path)
         if error
@@ -638,7 +813,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
             if dest.slice(-1) == JSpath.sep                                 // new location, else entirely new pathname
                 localdest = JSpath.join(localdest, JSpath.basename(srcpath))
         }
-        fs.lstat(localdest, closure(err, stat, local cmd, args) {
+        fs.stat(localdest, closure(err, stat, local cmd, args) {
             if !err && !options.overwrite
                 callback(Error("copy destination already exists",
                     {
@@ -649,6 +824,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
                         existing: localdest
                     }))
             else {
+                debuglog("==> Warning: files.copy needs to be rewritten with fs primitives")
                 if options.move {
                     cmd = "mv"
                     args = [localsrc, localdest] }
@@ -717,6 +893,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     files.minimize = closure minimize(input, callback, local child, stdinStream) {
         if !callback
             return (syncAdapter(minimize, input))
+        debuglog("==> Warning: files.minimize is deprecated")
         child = nodecp.execFile("uglifyjs",
             ["--compress", "drop_debugger=false", "--mangle", "eval"],      // ### uglifyjs options should be parameterized
             function(err, stdout, stderr) {
@@ -742,6 +919,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     files.unzip = closure unzip(inpath, outpath, callback) {
         if !callback
             return (syncAdapter(unzip, inpath, outpath))
+        debuglog("==> Warning: files.unzip is deprecated")
         nodecp.execFile("unzip",
             ["-qo", inpath, "-d", outpath],                                 // quiet; no queries
             { },                                                            // execution options
@@ -757,21 +935,27 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     //
     // touch
     //
-    // Execute the touch utility, returning the result as a standard tuple: `(error, result)
+    // Touch the specified file or directory, returning the result as a standard result tuple
+    // `(error, result). When only the path is specified this sets the last-access and last-modified
+    // times to the current Date(). Otherwise the dates are set to the specified value(s). Note that
+    // this sets the times of a symbolic link file itself, not the file the link points to.
     //
-    files.touch = closure touch(outpath, callback) {
+    files.touch = closure touch(path, atime, mtime, callback, local localpath) {
         if !callback
-            return (syncAdapter(touch, outpath))
-        nodecp.execFile("touch",
-            [outpath],
-            { },                                                            // execution options
-            function(err, stdout, stderr) {
-                if err
-                    callback(Error("touch failed", err, stderr))
-                else
-                    callback(false, { ok: true })
-            }
-        )
+            return (syncAdapter(touch, path, atime, mtime))
+        `(error, localpath) = localPath(path)
+        if error
+            return (asyncResult(callback, error))
+        if !atime && !mtime
+            atime = mtime = Date()
+        else if atime && !mtime
+            mtime = atime
+        fs.lutimes(localpath, atime, mtime, function(err) {
+            if err
+                callback(Error("touch failed", err))
+            else
+                callback(false, { ok: true })
+        })
     }
 
     //

package/frameworks/node/gitter.nlg

@@ -23,6 +23,28 @@ closure Gitter(fs, local gitt) {
     gitt = new(object, this)
     gitt.roots = {}
     
+    // gitPath
+    //
+    // Convert a Windows path to a posix (git) path if needed.
+    //
+    function gitPath(fspath) {
+        if fs.path.sep == "/"
+            fspath
+        else
+            fspath.split(fs.path.sep).join("/")
+    }
+        
+    // fsPath
+    //
+    // Convert a posix (git) path to a filesystem path if needed.
+    //
+    function fsPath(gitpath) {
+        if fs.path.sep == "/"
+            gitpath
+        else
+            gitpath.split("/").join(fs.path.sep)
+    }
+
     // repoRoot
     //
     // Compute the path from the fs root to the repo root.
@@ -54,11 +76,10 @@ closure Gitter(fs, local gitt) {
     // Compute the bridge path to an absolute repopath (which can point inside a repo) from the
     // phyiscal repo root. If these are the same, or an error occurs, then the result is "".
     //
-    
     function bridgePath(repopath, local top) {
         top = repoRoot(repopath).1
         if top && repopath.startsWith(top) && repopath.length > top.length
-           top = repopath.slice(top.length+1).concat("/")                   // move leading "/" of bridge path to trailing
+           top = repopath.slice(top.length+1).concat(fs.path.sep)           // move leading "/" of bridge path to trailing
         else
             ""                                                              // we are looking at the root, or an error
     }
@@ -151,12 +172,12 @@ closure Gitter(fs, local gitt) {
             outLE: "\x00"                                                   // lines delimited by nulls
         }
         if options.pathspec
-            execOptions.cmdargs = execOptions.cmdargs.concat("--", options.pathspec)
+            execOptions.cmdargs = execOptions.cmdargs.concat("--", gitPath(options.pathspec))
         result = []
         execOptions.outproc = function(output, liner, kill, local line, path) {
             while (line = liner.read())
                 if line != "" {
-                    path = line.substring(3)
+                    path = fsPath(line.substring(3))
                     if path.startsWith(bridge) {                            // must start with bridge to be within repopath
                         path = path.slice(bridge.length)
                         result.push({
@@ -183,7 +204,7 @@ closure Gitter(fs, local gitt) {
     // Retrieve the content of a specific file and revision. The file pathspec must be the path of
     // the file within the repo.
     
-    gitt.showfile = closure showfile(repopath, options, callback, local execOptions, result) {
+    gitt.showfile = closure showfile(repopath, options, callback, local execOptions) {
         if !callback
             return (syncAdapter(showfile, repopath, options))
         if !string(repopath)
@@ -192,7 +213,7 @@ closure Gitter(fs, local gitt) {
             return (asyncResult(callback, Error("both pathspec and hash required:", options.pathspec, options.hash)))
         repopath = fs.path.resolve(fs.rootpath, repopath)
         execOptions = {
-            cmdargs: ["show", options.hash.concat(":", bridgePath(repopath), options.pathspec)]
+            cmdargs: ["show", options.hash.concat(":", bridgePath(repopath), gitPath(options.pathspec))]
             execops: {
                 cwd: repopath
             }