Add HTTP server, Go native packages, hash verification, bump to v1.1.0

- http.listen with VM callback for serving HTTP from CColon
- Go native package loading via plugin system (Linux/macOS)
- SHA256 hash verification in install scripts
- Platform-specific console terminal size (fixes Windows build)
- Updated docs: sint in variables/methods reference, package loading details

Author: TRC-Loop

.github/workflows/release.yml

@@ -71,6 +71,12 @@ jobs:
           path: artifacts
           merge-multiple: true
 
+      - name: Generate checksums
+        run: |
+          cd artifacts
+          sha256sum * > checksums.txt
+          cat checksums.txt
+
       - name: Create or update release
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

ccolon/main.go

@@ -17,7 +17,7 @@ import (
 	"github.com/TRC-Loop/ccolon/vm"
 )
 
-const version = "1.0.0"
+const version = "1.1.0"
 
 func main() {
 	if len(os.Args) < 2 {
@@ -324,6 +324,9 @@ func runFile(source string, baseDir string) error {
 		return compileSource(string(data))
 	}
 
+	// Load installed packages
+	pkg.LoadPackages(machine, compileSource)
+
 	if err := machine.Run(fn); err != nil {
 		return err
 	}

ccolon/pkg/loader.go

@@ -0,0 +1,71 @@
+package pkg
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/TRC-Loop/ccolon/compiler"
+	"github.com/TRC-Loop/ccolon/vm"
+)
+
+// LoadPackages scans ~/.ccolon/packages/ and loads all installed packages
+// into the VM. CColon packages are registered as file import sources.
+// Go native packages are compiled and loaded as plugins.
+func LoadPackages(machine *vm.VM, compileSource func(string) (*compiler.FuncObject, error)) error {
+	pkgDir, err := packagesDir()
+	if err != nil {
+		return nil // no packages dir, nothing to load
+	}
+
+	entries, err := os.ReadDir(pkgDir)
+	if err != nil {
+		return nil
+	}
+
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		dir := filepath.Join(pkgDir, e.Name())
+		manifestPath := filepath.Join(dir, "ccolon.json")
+		data, err := os.ReadFile(manifestPath)
+		if err != nil {
+			continue // skip packages without manifest
+		}
+
+		var m Manifest
+		if err := json.Unmarshal(data, &m); err != nil {
+			continue
+		}
+
+		switch m.Type {
+		case "go":
+			if err := LoadGoPlugin(dir, machine); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to load Go package '%s': %s\n", m.Name, err)
+			}
+		default:
+			// CCL package: register as an importable module by running the entry file
+			entry := m.Entry
+			if entry == "" {
+				entry = "lib.ccl"
+			}
+			entryPath := filepath.Join(dir, entry)
+			source, err := os.ReadFile(entryPath)
+			if err != nil {
+				continue // skip if entry file doesn't exist
+			}
+			fn, err := compileSource(string(source))
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to compile package '%s': %s\n", m.Name, err)
+				continue
+			}
+			// Run the package code to register its globals/functions
+			if err := machine.Run(fn); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to load package '%s': %s\n", m.Name, err)
+			}
+		}
+	}
+	return nil
+}

ccolon/pkg/manifest.go

@@ -16,6 +16,8 @@ type Manifest struct {
 	Description  string            `json:"description,omitempty"`
 	Dependencies map[string]string `json:"dependencies,omitempty"`
 	Registry     string            `json:"registry,omitempty"`
+	Type         string            `json:"type,omitempty"`  // "ccl" (default) or "go"
+	Entry        string            `json:"entry,omitempty"` // entry point file
 }
 
 // RegistryURL returns the effective registry URL, checking the manifest field

ccolon/pkg/plugin_unix.go

@@ -0,0 +1,46 @@
+//go:build linux || darwin
+
+package pkg
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"plugin"
+
+	"github.com/TRC-Loop/ccolon/vm"
+)
+
+// LoadGoPlugin compiles and loads a Go native package.
+// The package directory must contain Go source files with a Register function.
+func LoadGoPlugin(pkgDir string, machine *vm.VM) error {
+	soPath := filepath.Join(pkgDir, "plugin.so")
+
+	// Compile the plugin
+	cmd := exec.Command("go", "build", "-buildmode=plugin", "-o", soPath, ".")
+	cmd.Dir = pkgDir
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to compile Go plugin in %s: %s\n%s", pkgDir, err, string(output))
+	}
+
+	// Load the plugin
+	p, err := plugin.Open(soPath)
+	if err != nil {
+		return fmt.Errorf("failed to load plugin %s: %s", soPath, err)
+	}
+
+	// Look up the Register function
+	sym, err := p.Lookup("Register")
+	if err != nil {
+		return fmt.Errorf("plugin %s has no Register function: %s", pkgDir, err)
+	}
+
+	registerFn, ok := sym.(func(*vm.VM))
+	if !ok {
+		return fmt.Errorf("plugin %s Register function has wrong signature (expected func(*vm.VM))", pkgDir)
+	}
+
+	registerFn(machine)
+	return nil
+}

ccolon/pkg/plugin_windows.go

@@ -0,0 +1,14 @@
+//go:build windows
+
+package pkg
+
+import (
+	"fmt"
+
+	"github.com/TRC-Loop/ccolon/vm"
+)
+
+// LoadGoPlugin is not supported on Windows.
+func LoadGoPlugin(pkgDir string, machine *vm.VM) error {
+	return fmt.Errorf("Go native plugins are not supported on Windows")
+}

ccolon/stdlib/console.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"os"
 	"strings"
-	"syscall"
-	"unsafe"
 
 	"github.com/TRC-Loop/ccolon/vm"
 )
@@ -108,28 +106,11 @@ func NewConsoleModule() *vm.ModuleValue {
 			"getSize": {
 				Name: "console.getSize",
 				Fn: func(args []vm.Value) (vm.Value, error) {
-					type winsize struct {
-						Row    uint16
-						Col    uint16
-						Xpixel uint16
-						Ypixel uint16
-					}
-					ws := &winsize{}
-					_, _, err := syscall.Syscall(syscall.SYS_IOCTL,
-						uintptr(syscall.Stdout),
-						uintptr(syscall.TIOCGWINSZ),
-						uintptr(unsafe.Pointer(ws)))
-
-					width := int64(80)
-					height := int64(24)
-					if err == 0 {
-						width = int64(ws.Col)
-						height = int64(ws.Row)
-					}
+					w, h := getTerminalSize()
 					return &vm.DictValue{
 						Entries: map[string]vm.Value{
-							"width":  &vm.IntValue{Val: width},
-							"height": &vm.IntValue{Val: height},
+							"width":  &vm.IntValue{Val: int64(w)},
+							"height": &vm.IntValue{Val: int64(h)},
 						},
 						Order: []string{"width", "height"},
 					}, nil

ccolon/stdlib/console_size_unix.go

@@ -0,0 +1,27 @@
+//go:build !windows
+
+package stdlib
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func getTerminalSize() (width, height int) {
+	type winsize struct {
+		Row    uint16
+		Col    uint16
+		Xpixel uint16
+		Ypixel uint16
+	}
+	ws := &winsize{}
+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL,
+		uintptr(syscall.Stdout),
+		uintptr(syscall.TIOCGWINSZ),
+		uintptr(unsafe.Pointer(ws)))
+
+	if err != 0 {
+		return 80, 24
+	}
+	return int(ws.Col), int(ws.Row)
+}

ccolon/stdlib/console_size_windows.go

@@ -0,0 +1,41 @@
+//go:build windows
+
+package stdlib
+
+import (
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+func getTerminalSize() (width, height int) {
+	cmd := exec.Command("cmd", "/c", "mode", "con")
+	cmd.Stdin = os.Stdin
+	out, err := cmd.Output()
+	if err != nil {
+		return 80, 24
+	}
+	lines := strings.Split(string(out), "\n")
+	w, h := 80, 24
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if strings.Contains(line, "Columns") || strings.Contains(line, "Spalten") {
+			parts := strings.Fields(line)
+			if len(parts) > 0 {
+				if n, err := strconv.Atoi(parts[len(parts)-1]); err == nil {
+					w = n
+				}
+			}
+		}
+		if strings.Contains(line, "Lines") || strings.Contains(line, "Zeilen") {
+			parts := strings.Fields(line)
+			if len(parts) > 0 {
+				if n, err := strconv.Atoi(parts[len(parts)-1]); err == nil {
+					h = n
+				}
+			}
+		}
+	}
+	return w, h
+}

ccolon/stdlib/http.go

@@ -9,7 +9,7 @@ import (
 	"github.com/TRC-Loop/ccolon/vm"
 )
 
-func NewHttpModule() *vm.ModuleValue {
+func NewHttpModule(machine *vm.VM) *vm.ModuleValue {
 	return &vm.ModuleValue{
 		Name: "http",
 		Methods: map[string]*vm.NativeFuncValue{
@@ -43,12 +43,89 @@ func NewHttpModule() *vm.ModuleValue {
 					if !ok {
 						return nil, fmt.Errorf("http.listen() handler must be a function")
 					}
-					_ = handler // handler will be called via VM callback
+
 					addr := fmt.Sprintf(":%d", port.Val)
 					fmt.Printf("CColon HTTP server listening on %s\n", addr)
-					// We store the handler ref but can't call it without VM access.
-					// The server integration is done through the VM's CallFunc.
-					return nil, fmt.Errorf("http.listen() requires VM callback support (use the listen helper)")
+
+					mux := http.NewServeMux()
+					mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+						body, _ := io.ReadAll(r.Body)
+						r.Body.Close()
+
+						// Build request dict
+						headerDict := &vm.DictValue{
+							Entries: make(map[string]vm.Value),
+							Order:   []string{},
+						}
+						for key := range r.Header {
+							lk := strings.ToLower(key)
+							headerDict.Entries[lk] = &vm.StringValue{Val: r.Header.Get(key)}
+							headerDict.Order = append(headerDict.Order, lk)
+						}
+
+						reqDict := &vm.DictValue{
+							Entries: map[string]vm.Value{
+								"method":  &vm.StringValue{Val: r.Method},
+								"path":    &vm.StringValue{Val: r.URL.Path},
+								"body":    &vm.StringValue{Val: string(body)},
+								"headers": headerDict,
+								"query":   &vm.StringValue{Val: r.URL.RawQuery},
+							},
+							Order: []string{"method", "path", "body", "headers", "query"},
+						}
+
+						result, err := machine.CallFunc(handler, []vm.Value{reqDict})
+						if err != nil {
+							http.Error(w, "handler error: "+err.Error(), 500)
+							return
+						}
+
+						// Handle response
+						switch resp := result.(type) {
+						case *vm.StringValue:
+							w.Header().Set("Content-Type", "text/plain")
+							w.WriteHeader(200)
+							w.Write([]byte(resp.Val))
+						case *vm.DictValue:
+							// Expect {status: int, body: string, headers: dict}
+							status := 200
+							respBody := ""
+							if s, ok := resp.Entries["status"]; ok {
+								if iv, ok := s.(*vm.IntValue); ok {
+									status = int(iv.Val)
+								}
+							}
+							if b, ok := resp.Entries["body"]; ok {
+								if sv, ok := b.(*vm.StringValue); ok {
+									respBody = sv.Val
+								}
+							}
+							if h, ok := resp.Entries["headers"]; ok {
+								if hd, ok := h.(*vm.DictValue); ok {
+									for key, val := range hd.Entries {
+										if sv, ok := val.(*vm.StringValue); ok {
+											w.Header().Set(key, sv.Val)
+										}
+									}
+								}
+							}
+							w.WriteHeader(status)
+							w.Write([]byte(respBody))
+						case *vm.NilValue:
+							w.WriteHeader(204)
+						default:
+							w.Header().Set("Content-Type", "text/plain")
+							w.WriteHeader(200)
+							w.Write([]byte(result.String()))
+						}
+					})
+
+					// This blocks, so it won't return until the server stops
+					err := http.ListenAndServe(addr, mux)
+					if err != nil {
+						return nil, fmt.Errorf("http.listen() failed: %s", err)
+					}
+					return &vm.NilValue{}, nil
 				},
 			},
 		},