Add clients/shock-go zero-dependency Go client library and update CLI

Create a new Go client library at clients/shock-go/ that replaces the
vendored go-shock-client with a modern, stdlib-only implementation.

Key improvements over the old client:
- Fix Linkages JSON tag ("linkages" -> "linkage" matching server)
- Include VersionParts in JSON (was excluded with json:"-")
- Add missing Node fields: Locations, Restore
- Type ACL responses as *DisplayAcl instead of interface{}
- Type UnpackArchiveNode response as []Node instead of interface{}
- Add context.Context support on all methods
- Support custom *http.Client via WithHTTPClient option
- Remove log.Fatal calls (return errors instead)
- Remove deprecated ioutil usage throughout
- Stream multipart uploads via io.Pipe (no full-file buffering)
- Add new location management endpoints
- Add functional options pattern for node creation/updates

Update shock-client/ CLI to use the new library with identical behavior.
The server continues using the vendored old client (out of scope).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wilke

clients/shock-go/acl.go

@@ -0,0 +1,61 @@
+package shock
+
+import (
+	"context"
+	"net/url"
+)
+
+// GetAcl retrieves the ACL for a node.
+func (c *Client) GetAcl(ctx context.Context, nodeID string) (*DisplayAcl, error) {
+	var acl DisplayAcl
+	if err := c.doRequest(ctx, "GET", "/node/"+nodeID+"/acl", nil, &acl); err != nil {
+		return nil, err
+	}
+	return &acl, nil
+}
+
+// PutAcl adds users to an ACL type on a node.
+func (c *Client) PutAcl(ctx context.Context, nodeID, aclType, users string) (*DisplayAcl, error) {
+	query := url.Values{}
+	if users != "" {
+		query.Set("users", users)
+	}
+	var acl DisplayAcl
+	if err := c.doRequest(ctx, "PUT", "/node/"+nodeID+"/acl/"+aclType, query, &acl); err != nil {
+		return nil, err
+	}
+	return &acl, nil
+}
+
+// DeleteAcl removes users from an ACL type on a node.
+func (c *Client) DeleteAcl(ctx context.Context, nodeID, aclType, users string) (*DisplayAcl, error) {
+	query := url.Values{}
+	if users != "" {
+		query.Set("users", users)
+	}
+	var acl DisplayAcl
+	if err := c.doRequest(ctx, "DELETE", "/node/"+nodeID+"/acl/"+aclType, query, &acl); err != nil {
+		return nil, err
+	}
+	return &acl, nil
+}
+
+// MakePublic sets a node's read ACL to public.
+func (c *Client) MakePublic(ctx context.Context, nodeID string) (*DisplayAcl, error) {
+	var acl DisplayAcl
+	if err := c.doRequest(ctx, "PUT", "/node/"+nodeID+"/acl/public_read", nil, &acl); err != nil {
+		return nil, err
+	}
+	return &acl, nil
+}
+
+// ChownNode changes the owner of a node.
+func (c *Client) ChownNode(ctx context.Context, nodeID, user string) (*DisplayAcl, error) {
+	query := url.Values{}
+	query.Set("users", user)
+	var acl DisplayAcl
+	if err := c.doRequest(ctx, "PUT", "/node/"+nodeID+"/acl/owner", query, &acl); err != nil {
+		return nil, err
+	}
+	return &acl, nil
+}

clients/shock-go/client.go

@@ -0,0 +1,66 @@
+package shock
+
+import (
+	"net/http"
+	"time"
+)
+
+// Client is a Shock API client.
+type Client struct {
+	baseURL    string
+	token      string
+	authType   string
+	httpClient *http.Client
+	debug      bool
+}
+
+// Option configures a Client.
+type Option func(*Client)
+
+// New creates a new Shock client for the given base URL.
+func New(baseURL string, opts ...Option) *Client {
+	c := &Client{
+		baseURL:  baseURL,
+		authType: "OAuth",
+		httpClient: &http.Client{
+			Timeout: 60 * time.Second,
+		},
+	}
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+// WithToken sets the authentication token.
+func WithToken(token string) Option {
+	return func(c *Client) {
+		c.token = token
+	}
+}
+
+// WithAuthType sets the authorization type (e.g. "mgrast", "OAuth").
+func WithAuthType(authType string) Option {
+	return func(c *Client) {
+		c.authType = authType
+	}
+}
+
+// WithHTTPClient sets a custom HTTP client.
+func WithHTTPClient(hc *http.Client) Option {
+	return func(c *Client) {
+		c.httpClient = hc
+	}
+}
+
+// WithDebug enables debug logging to stderr.
+func WithDebug(debug bool) Option {
+	return func(c *Client) {
+		c.debug = debug
+	}
+}
+
+// SetToken updates the authentication token.
+func (c *Client) SetToken(token string) {
+	c.token = token
+}

clients/shock-go/download.go

@@ -0,0 +1,182 @@
+package shock
+
+import (
+	"compress/gzip"
+	"context"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+)
+
+type downloadConfig struct {
+	uncompress string
+	computeMD5 bool
+}
+
+// DownloadOption configures a DownloadToFile call.
+type DownloadOption func(*downloadConfig)
+
+// WithUncompress sets the decompression method for downloads (e.g. "gzip").
+func WithUncompress(method string) DownloadOption {
+	return func(cfg *downloadConfig) {
+		cfg.uncompress = method
+	}
+}
+
+// WithComputeMD5 enables MD5 checksum computation during download.
+func WithComputeMD5() DownloadOption {
+	return func(cfg *downloadConfig) {
+		cfg.computeMD5 = true
+	}
+}
+
+// Download streams a node's file data. The caller must close the returned ReadCloser.
+func (c *Client) Download(ctx context.Context, nodeID string) (io.ReadCloser, error) {
+	query := url.Values{"download": {""}}
+	u := c.buildURL("/node/"+nodeID, query)
+	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	c.setAuth(req)
+	c.debugf("GET %s (download)", u)
+
+	res, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode == http.StatusOK {
+		return res.Body, nil
+	}
+
+	// Error response — parse JSON envelope
+	defer res.Body.Close()
+	body, _ := io.ReadAll(res.Body)
+	var envelope struct {
+		Error []string `json:"error"`
+	}
+	if json.Unmarshal(body, &envelope) == nil && len(envelope.Error) > 0 {
+		return nil, &APIError{StatusCode: res.StatusCode, Errors: envelope.Error}
+	}
+	return nil, &APIError{StatusCode: res.StatusCode, Errors: []string{string(body)}}
+}
+
+// DownloadRange streams a byte range from a node's file.
+func (c *Client) DownloadRange(ctx context.Context, nodeID string, seek, length int64) (io.ReadCloser, error) {
+	query := url.Values{
+		"download": {""},
+		"seek":     {strconv.FormatInt(seek, 10)},
+		"length":   {strconv.FormatInt(length, 10)},
+	}
+	u := c.buildURL("/node/"+nodeID, query)
+	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	c.setAuth(req)
+
+	res, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode == http.StatusOK {
+		return res.Body, nil
+	}
+
+	defer res.Body.Close()
+	body, _ := io.ReadAll(res.Body)
+	var envelope struct {
+		Error []string `json:"error"`
+	}
+	if json.Unmarshal(body, &envelope) == nil && len(envelope.Error) > 0 {
+		return nil, &APIError{StatusCode: res.StatusCode, Errors: envelope.Error}
+	}
+	return nil, &APIError{StatusCode: res.StatusCode, Errors: []string{string(body)}}
+}
+
+// DownloadToFile downloads a node's file to a local path, optionally decompressing and computing MD5.
+func (c *Client) DownloadToFile(ctx context.Context, nodeID, filepath string, opts ...DownloadOption) (int64, string, error) {
+	cfg := &downloadConfig{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+
+	body, err := c.Download(ctx, nodeID)
+	if err != nil {
+		return 0, "", err
+	}
+	defer body.Close()
+
+	localFile, err := os.Create(filepath)
+	if err != nil {
+		return 0, "", err
+	}
+	defer localFile.Close()
+
+	md5h := md5.New()
+	var size int64
+
+	if cfg.uncompress == "gzip" {
+		var src io.Reader = body
+		if cfg.computeMD5 {
+			// MD5 on compressed stream, then decompress
+			pReader, pWriter := io.Pipe()
+			defer pReader.Close()
+			dst := io.MultiWriter(pWriter, md5h)
+			go func() {
+				io.Copy(dst, body)
+				pWriter.Close()
+			}()
+			src = pReader
+		}
+		gr, gerr := gzip.NewReader(src)
+		if gerr != nil {
+			return 0, "", gerr
+		}
+		defer gr.Close()
+		size, err = io.Copy(localFile, gr)
+		if err != nil {
+			return 0, "", err
+		}
+	} else {
+		var dst io.Writer
+		if cfg.computeMD5 {
+			dst = io.MultiWriter(localFile, md5h)
+		} else {
+			dst = localFile
+		}
+		size, err = io.Copy(dst, body)
+		if err != nil {
+			return 0, "", err
+		}
+	}
+
+	var md5sum string
+	if cfg.computeMD5 {
+		md5sum = fmt.Sprintf("%x", md5h.Sum(nil))
+	}
+	return size, md5sum, nil
+}
+
+// GetDownloadURL gets a pre-authenticated download URL for a node.
+func (c *Client) GetDownloadURL(ctx context.Context, nodeID string) (*PreAuthResponse, error) {
+	query := url.Values{"download_url": {""}}
+	var resp PreAuthResponse
+	if err := c.doRequest(ctx, "GET", "/node/"+nodeID, query, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// DownloadURL returns the direct download URL for a node (no pre-auth).
+func (c *Client) DownloadURL(nodeID string) string {
+	query := url.Values{"download": {""}}
+	return c.buildURL("/node/"+nodeID, query)
+}

clients/shock-go/errors.go

@@ -0,0 +1,19 @@
+package shock
+
+import (
+	"fmt"
+	"strings"
+)
+
+// APIError represents an error returned by the Shock API.
+type APIError struct {
+	StatusCode int
+	Errors     []string
+}
+
+func (e *APIError) Error() string {
+	if len(e.Errors) > 0 {
+		return fmt.Sprintf("shock API error (status %d): %s", e.StatusCode, strings.Join(e.Errors, "; "))
+	}
+	return fmt.Sprintf("shock API error (status %d)", e.StatusCode)
+}

clients/shock-go/go.mod

@@ -0,0 +1,3 @@
+module github.com/MG-RAST/Shock/clients/shock-go
+
+go 1.22