feat: add ww export subcommand for IPFS file/directory publishing

- Implement export command equivalent to 'ipfs add -r <path>'
- Add recursive directory and file export to IPFS
- Print IPFS path to stdout followed by newline on success
- Support configurable IPFS endpoint via --ipfs flag or WW_IPFS env var
- Add comprehensive unit tests with proper temp directory handling
- Include detailed documentation and usage examples
- Integrate with existing ww command infrastructure

The export command enables users to publish local content to IPFS
for use with other Wetware commands like 'ww run'.

Author: lthibault

cmd/ww/export/README.md

@@ -0,0 +1,136 @@
+# Wetware Export Command
+
+The `ww export` command adds files and directories to IPFS recursively, equivalent to `ipfs add -r <path>`.
+
+## Overview
+
+The export command provides a convenient way to publish local files and directories to IPFS, making them available via IPFS paths that can be shared, referenced, or used by other Wetware commands.
+
+## Usage
+
+```bash
+ww export <path>
+```
+
+## Arguments
+
+- **`<path>`**: The local filesystem path to export. Can be:
+  - A file path (e.g., `./document.txt`)
+  - A directory path (e.g., `./my-project/`)
+  - Current directory (`.`)
+  - Absolute paths (e.g., `/home/user/documents`)
+
+## Options
+
+- **`--ipfs`**: IPFS API endpoint (default: `/dns4/localhost/tcp/5001/http`)
+  - Can also be set via `WW_IPFS` environment variable
+  - Supports multiaddr, URL, or local path formats
+
+## Examples
+
+### Export a single file
+```bash
+# Export a text file
+ww export document.txt
+# Output: /ipfs/QmHash...
+
+# Export with custom IPFS endpoint
+ww export --ipfs=/ip4/127.0.0.1/tcp/5001/http document.txt
+```
+
+### Export a directory
+```bash
+# Export current directory
+ww export .
+
+# Export a specific directory
+ww export /path/to/my-project
+
+# Export with environment variable
+WW_IPFS=/dns4/localhost/tcp/5001/http ww export ./data/
+```
+
+### Export for sharing
+```bash
+# Export a project directory
+ww export ./my-app/
+
+# The resulting IPFS path can be shared with others
+# They can then use: ww run /ipfs/QmHash.../my-app
+```
+
+## How It Works
+
+1. **Path Resolution**: The command resolves relative paths to absolute paths
+2. **File Type Detection**: Determines if the path is a file or directory
+3. **Recursive Processing**: For directories, recursively processes all subdirectories and files
+4. **IPFS Addition**: Uses the IPFS Unixfs API to add content to the network
+5. **Output**: Prints the resulting IPFS path to stdout followed by a newline
+
+## Integration with Other Commands
+
+The exported IPFS paths can be used with other Wetware commands:
+
+```bash
+# Export a binary
+ww export ./my-program
+
+# Run the exported binary
+ww run /ipfs/QmHash.../my-program --help
+
+# Export a project directory
+ww export ./my-project/
+
+# Run from the exported directory
+ww run /ipfs/QmHash.../my-project/
+```
+
+## Error Handling
+
+The command provides clear error messages for common issues:
+
+- **Missing argument**: "export requires exactly one argument: <path>"
+- **Path not found**: "path does not exist: /path/to/file"
+- **IPFS connection issues**: "failed to add to IPFS: [specific error]"
+
+## Requirements
+
+- IPFS daemon running and accessible
+- Proper IPFS API endpoint configuration
+- Read access to the specified path
+
+## Environment Variables
+
+- **`WW_IPFS`**: IPFS API endpoint (overrides `--ipfs` flag)
+
+## Security Considerations
+
+- The command only reads files, never modifies them
+- Exported content is publicly available on IPFS (unless using private networks)
+- Consider what content you're making publicly accessible
+- Use appropriate IPFS network configuration for sensitive content
+
+## Troubleshooting
+
+### Connection Issues
+```bash
+# Check if IPFS daemon is running
+ipfs id
+
+# Test IPFS API endpoint
+curl http://localhost:5001/api/v0/version
+```
+
+### Permission Issues
+```bash
+# Ensure read access to the path
+ls -la /path/to/export
+
+# Check IPFS daemon permissions
+ipfs config show | grep "API"
+```
+
+### Large File Handling
+- Large files are automatically chunked by IPFS
+- Progress is not displayed (use `ipfs add` directly for progress)
+- Memory usage scales with file size

cmd/ww/export/export.go

@@ -0,0 +1,188 @@
+package export
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/ipfs/boxo/files"
+	iface "github.com/ipfs/kubo/core/coreiface"
+	"github.com/urfave/cli/v2"
+	"github.com/wetware/go/cmd/internal/flags"
+	"github.com/wetware/go/util"
+)
+
+var env Env
+
+func Command() *cli.Command {
+	return &cli.Command{
+		Name:      "export",
+		ArgsUsage: "<path>",
+		Usage:     "Add a file or directory to IPFS recursively",
+		Description: `Add a file or directory to IPFS recursively, equivalent to 'ipfs add -r <path>'.
+		
+The command will:
+1. Read the specified path from the local filesystem
+2. Add it to IPFS recursively (including all subdirectories and files)
+3. Print the resulting IPFS path to stdout followed by a newline
+
+Examples:
+  ww export /path/to/file.txt
+  ww export /path/to/directory
+  ww export .  # Export current directory`,
+		Flags: append([]cli.Flag{
+			&cli.StringFlag{
+				Name:    "ipfs",
+				EnvVars: []string{"WW_IPFS"},
+				Value:   "/dns4/localhost/tcp/5001/http",
+				Usage:   "IPFS API endpoint",
+			},
+		}, flags.CapabilityFlags()...),
+
+		Before: func(c *cli.Context) error {
+			return env.Boot(c.String("ipfs"))
+		},
+		After: func(c *cli.Context) error {
+			return env.Close()
+		},
+
+		Action: Main,
+	}
+}
+
+func Main(c *cli.Context) error {
+	ctx := c.Context
+
+	if c.NArg() != 1 {
+		return cli.Exit("export requires exactly one argument: <path>", 1)
+	}
+
+	argPath := c.Args().First()
+	if argPath == "" {
+		return cli.Exit("path cannot be empty", 1)
+	}
+
+	// Resolve the path to absolute
+	absPath, err := filepath.Abs(argPath)
+	if err != nil {
+		return fmt.Errorf("failed to resolve path %s: %w", argPath, err)
+	}
+
+	// Check if path exists
+	if _, err := os.Stat(absPath); os.IsNotExist(err) {
+		return cli.Exit(fmt.Sprintf("path does not exist: %s", absPath), 1)
+	}
+
+	// Add the file/directory to IPFS
+	ipfsPath, err := env.AddToIPFS(ctx, absPath)
+	if err != nil {
+		return fmt.Errorf("failed to add to IPFS: %w", err)
+	}
+
+	// Print the IPFS path to stdout followed by a newline
+	fmt.Println(ipfsPath)
+	return nil
+}
+
+type Env struct {
+	IPFS iface.CoreAPI
+}
+
+func (env *Env) Boot(addr string) error {
+	var err error
+	env.IPFS, err = util.LoadIPFSFromName(addr)
+	return err
+}
+
+func (env *Env) Close() error {
+	// No cleanup needed for IPFS client
+	return nil
+}
+
+// AddToIPFS adds a file or directory to IPFS recursively
+func (env *Env) AddToIPFS(ctx context.Context, localPath string) (string, error) {
+	// Get file info to determine if it's a directory
+	fileInfo, err := os.Stat(localPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to stat %s: %w", localPath, err)
+	}
+
+	var node files.Node
+	if fileInfo.IsDir() {
+		// Handle directory
+		node, err = env.CreateDirectoryNode(ctx, localPath)
+		if err != nil {
+			return "", fmt.Errorf("failed to create directory node: %w", err)
+		}
+	} else {
+		// Handle single file
+		node, err = env.CreateFileNode(ctx, localPath)
+		if err != nil {
+			return "", fmt.Errorf("failed to create file node: %w", err)
+		}
+	}
+
+	// Check if IPFS client is available
+	if env.IPFS == nil {
+		return "", fmt.Errorf("IPFS client not initialized")
+	}
+
+	// Add the node to IPFS using Unixfs API
+	path, err := env.IPFS.Unixfs().Add(ctx, node)
+	if err != nil {
+		return "", fmt.Errorf("failed to add to IPFS: %w", err)
+	}
+
+	return path.String(), nil
+}
+
+// CreateFileNode creates a files.Node for a single file
+func (env *Env) CreateFileNode(ctx context.Context, filePath string) (files.Node, error) {
+	// Read the file content into memory
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a file node from the content
+	return files.NewBytesFile(content), nil
+}
+
+// CreateDirectoryNode creates a files.Node for a directory recursively
+func (env *Env) CreateDirectoryNode(ctx context.Context, dirPath string) (files.Node, error) {
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a map to hold directory contents
+	dirMap := make(map[string]files.Node)
+
+	for _, entry := range entries {
+		entryPath := filepath.Join(dirPath, entry.Name())
+
+		if entry.IsDir() {
+			// Recursively handle subdirectories
+			childNode, err := env.CreateDirectoryNode(ctx, entryPath)
+			if err != nil {
+				return nil, err
+			}
+
+			// Add subdirectory to the map
+			dirMap[entry.Name()] = childNode
+		} else {
+			// Handle files
+			childNode, err := env.CreateFileNode(ctx, entryPath)
+			if err != nil {
+				return nil, err
+			}
+
+			// Add file to the map
+			dirMap[entry.Name()] = childNode
+		}
+	}
+
+	// Create directory from the map
+	return files.NewMapDirectory(dirMap), nil
+}