Free shell software for linux

udpShell is a remote shell that uses UDP instead of TCP. It uses a client-server architecture (udpShell as the daemon and udpClient as the client).

Installation:
cd src
make
this sould make the work

if you like edit the Makefile to reflect your system, preferences.

xen-shell is a simple console application which allows you to easily allow the owner of a single Xen instance to control it, without the overhead of a web-based control panel.
Using this shell users may:
- Boot/Shutodwn their Xen guest.
- Reboot their Xen guest.
- Connect to the serial console of their runing Xen guest.
- Reimage their system to a pristine state, via xen-tools.
- Manipulate their reverse DNS information
The shell features command history, command completion, and integrated help.
It is ideal for a hosting company who wishes to over "virtual machine" hosting to their customers, and allow them to control their own instance.

rwdshell uses the RubyWebDialogs GUI to run shell commands in a Web browser. It uses the rwdtinker framework for removal and installation of applets.

You have a Ruby eval screen, a shell command line, and a shell script runner. You can edit scripts and run Ruby scripts.

LDAP Shell is an interactive LDAP shell written in Perl and allowing basic administrative functionality, such as crawling the directory tree and modifying entries.
It is composed of two parts: Net::LDAP::Config, and ldapsh.
Net::LDAP::Config is a library for simplifying and centralizing access to your LDAP repositories. Instead of having every single script ask for your ldap server and search base, or have it hard coded, you can simply use this library:
my $config = Net::LDAP::Config->new("default");
Its got a couple other nice features, like the fact that it caches your LDAP UID (per host), so you should only ever have to type it in once. Its pretty well documented, so perldoc Net::LDAP::config should get you the rest of the way.
ldapsh, and its corresponding library Net::LDAP::Shell, provide (shockingly) the shell behaviour. When run, ldapsh drops you into a (very simple) interpreter.
Even given its simplicity, though, ldapsh is still very useful: You can use it to walk your LDAP tree, you can clone existing objects (using the clone command), remove objects (can you guess the command?), and create new objects using new.
The new command, when provided one or more objectclasses, will automatically retrieve the required and optional attributes for those objectclasses, which can be a great time-saver.
Enhancements:
- A lot of cleanup, some new commands, and Term::ReadKey support.

JSON::Shell is an interactive shell for performing JSON and JSON-RPC requests.

SYNOPSIS

$ bin/jsonshell

JSON::Shell 1.0
www.example.com/json-rpc-demo$ post { "id": 1, "method": "echoObject", "params": { "o": [ "YAY JSON~" ] } }
REQUEST: $VAR1 = {
params => {
o => [
YAY JSON~
]
},
method => echoObject,
id => 1
};

RESPONSE: $VAR1 = {
id => 1,
result => [
YAY JSON~
]
};

www.example.com/json-rpc-demo$

JSON::Shell provides an interactive debugger and workbench for JSON based web services.

Fry::Shell is a flexible shell framework which encourages using loadable libraries of functions.
SYNOPSIS
From the commandline: perl -MFry::Shell -eshell
OR
In a script:
package MyShell;
use Fry::Shell;
#subs
sub evalIt {
my $cls = shift;
my $code = ($cls->Flag(strict)) ? use strict; : ;
$code .= "@_";
eval "$code";
}
sub listStations {
my $cls = shift;
my @stations = ( {name=>high energy trance/techno,ip=>http://64.236.34.196:80/stream/1003},
{name=>macondo salsa,ip=>http://165.132.105.108:8000},
{name=>new age,ip=>http://64.236.34.67:80/stream/2004},
);
$cls->saveArray(map{$_->{ip}} @stations);
return map {$_->{name}} @stations;
}
#set shell prompt
my $prompt = "Clever prompt: ";
#initialize shell and load a command and an option
my $sh = Fry::Shell->new(prompt=>$prompt,
load_obj=>{ cmds=>{listStations=>{a=>lS}},
opts=>{strict=>{type=>flag,a=>n,default=>0}} }
);
#begin shell loop
$sh->shell(@ARGV);
####end of example, start of other possible methods
#run shell once
$sh->once(@ARGV);
#loads libraries and runs each librarys &_initLib
$sh->initLibs(@modules);
$sh->loadFile($file);
$sh->loadPlugins($myplugin);
$sh->runCmd($cmd);
Fry::Shell is a simple and flexible way to create a shell. Unlike most other light-weight shells, this module facilitates (un)loading libraries of functions and thus encourages creating shells tailored to several modules. Although the shell is currently only viewable at the commandline, the framework is flexible enough to support other views (especially a web one. This module is mainly serving(will serve) as the model in an MVC framework.
From a user perspective it helps to know that a shell session consists of mainly four shell components (whose classes are known as core classes) : libraries (lib), commands (cmd), options (opt) and variables(var). Commands and options are the same as in any shell environment: a command mapping to a function and an option changing the behavior of a command ie changing variables within it or calling functions before the command. Variables store all the configurable data, including data relating to these commands and options. Libraries are containers for a related group of these components.
Main features:
- Loading/unloading shell components at runtime.
- Flexible framework for using shell features via plugins. You can even set up a bare minimum shell needing no external modules! Currently plugins exist for dumping data,readline support,reading shell configurations and viewing shell output.
- Commands and options can be aliased for minimal typing at the commandline.
- Commands can have help and usage defined.
- Commands can have user-defined argument types. One defines argument types by subroutines or tests that they should pass. These tests are then applied to a commands defined argument(s). With defined argument types, one can also define autocompletion routines for a commands arguments.
- Options can modify variables. Since variables exist for almost every aspect of the shell, options can change many core shell functions. A handy example is parsecmd which names the current parse subroutine for the current line. Changing this var would change how the input after the options is parsed.
- Options can have different behaviors defined including the ability to invoke subroutines when called or to maintain a value for a specified amount of iterations.
- Default options include menu which numbers output and allows the next command to reference them by number.
- Page output with preferred pager.
- Multiline mode.
- Comes with a decent default library,Fry::Lib::Default, to dump,list or unload any shell component, run system commands,evaluate perl statements and execute methods of autoloaded libraries.

Group Shell is a tool to aggregate several remote shells into one. It is used to launch an interactive remote shell on many machines at once. Group Shell is written in Python and requires Python ≥ 2.4.

There is a control shell accessible with Ctrl-C that is used to list some information about the current remote shells. It also allows common terminal manipulations like sending a Ctrl-C, Ctrl-Z, Ctrl-D …

The prompt shows the number of listening shells and the number of active shell. A shell is said to be listening if its prompt has returned and it is accepting commands, active shells are those whose connection is still alive. Shells can be individually enabled and disabled.

Here is the transcript of a sample session:

[g ~/gsh]$ ./gsh.py machine{0-9}

[10/10]> date

machine4: ven nov 10 23:26:36 CET 2006
machine7: ven nov 10 23:26:36 CET 2006
machine3: ven nov 10 23:26:36 CET 2006
machine5: ven nov 10 23:26:36 CET 2006
machine9: ven nov 10 23:26:36 CET 2006
machine0: ven nov 10 23:26:36 CET 2006
machine2: ven nov 10 23:26:36 CET 2006
machine1: ven nov 10 23:26:37 CET 2006
machine6: ven nov 10 23:26:37 CET 2006
machine8: ven nov 10 23:26:37 CET 2006
[10/10]>
Now, Ctrl-C is pressed, it triggers the control shell.
(Cmd) help

Documented commands (type help < topic >):

EOF enable list send_eof set_print_first
continue get_print_first quit send_sigint unset_print_first
disable help reconnect send_sigtstp

(Cmd) list
machine0 fd:3 r:3 w:0 active:True enabled:True idle
machine1 fd:4 r:3 w:0 active:True enabled:True idle
machine2 fd:5 r:3 w:0 active:True enabled:True idle
machine3 fd:6 r:3 w:0 active:True enabled:True idle
machine4 fd:7 r:3 w:0 active:True enabled:True idle
machine5 fd:8 r:3 w:0 active:True enabled:True idle
machine6 fd:9 r:3 w:0 active:True enabled:True idle
machine7 fd:10 r:3 w:0 active:True enabled:True idle
machine8 fd:11 r:3 w:0 active:True enabled:True idle
machine9 fd:12 r:3 w:0 active:True enabled:True idle

10 active shells, 0 dead shells, total: 10
(Cmd) quit
[g ~/gsh]$

True3D*Shell is an open source 3D desktop environment that allows users to experience 3D browsing in a virtual reality universe where information is organized in bubbles connected by pipes. True3D*Shell is based on POSIX, Win32, FreeGLUT, OpenGL and MQ4CPP, and runs on IA32 and IA64 SMP platforms.
A user can browse local and remote filesystems and download and run selected files. It includes a robot mode that allows you to browse automatically.
Main features:
- Shell : provides access to the kernel services
- Desktop environment : offers a graphical user interface (GUI) solution to operate a computer
- Avatar : provides a fantastic representations of a persons self with witch user can explore the virtual universe.
- Virtual Reality : users can interact with a virtual environment either through the use of standard input devices such as a keyboard and mouse, or through multimodal devices.
- MVC paradigm : is a software architecture that separates an applications data model, user interface, and control logic into three distinct components.
- Multithreading : Threads are a way for a program to split itself into two or more simultaneously running tasks. Multiple threads can be executed in parallel on many computer systems.
- Grid computing : provides the ability to perform higher throughput computing by taking advantage of many networked computers to model a virtual computer architecture that is able to distribute process execution across a parallel infrastructure.
- MOM paradigms : Message Oriented Middleware is a category of inter-application communication software that relies on asynchronous message passing as opposed to a request/response metaphor.