@awiki/cli 0.0.1-beta.2

package/internal/output/output.go

@@ -0,0 +1,350 @@
+package output
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/itchyny/gojq"
+)
+
+type Format string
+
+const (
+	FormatJSON   Format = "json"
+	FormatPretty Format = "pretty"
+	FormatNDJSON Format = "ndjson"
+	FormatTable  Format = "table"
+)
+
+type IdentityMeta struct {
+	Name string `json:"name,omitempty"`
+	DID  string `json:"did,omitempty"`
+}
+
+type Meta struct {
+	Version  string        `json:"version"`
+	Identity *IdentityMeta `json:"identity,omitempty"`
+	DryRun   bool          `json:"dry_run"`
+	Format   string        `json:"format"`
+}
+
+type SuccessEnvelope struct {
+	OK       bool           `json:"ok"`
+	Command  string         `json:"command"`
+	Data     any            `json:"data,omitempty"`
+	Warnings []string       `json:"warnings,omitempty"`
+	Summary  string         `json:"summary,omitempty"`
+	Notice   map[string]any `json:"_notice,omitempty"`
+	Meta     Meta           `json:"meta"`
+}
+
+type ErrorDetail struct {
+	Code      string `json:"code"`
+	Message   string `json:"message"`
+	Hint      string `json:"hint,omitempty"`
+	Retryable bool   `json:"retryable"`
+	Details   any    `json:"details,omitempty"`
+}
+
+type ErrorEnvelope struct {
+	OK     bool           `json:"ok"`
+	Error  ErrorDetail    `json:"error"`
+	Notice map[string]any `json:"_notice,omitempty"`
+	Meta   Meta           `json:"meta"`
+}
+
+type ExitError struct {
+	Code   int
+	Detail ErrorDetail
+}
+
+func (e *ExitError) Error() string {
+	if e == nil {
+		return ""
+	}
+	return e.Detail.Message
+}
+
+func NewExitError(code string, exitCode int, message string, hint string) *ExitError {
+	return &ExitError{
+		Code: exitCode,
+		Detail: ErrorDetail{
+			Code:      code,
+			Message:   message,
+			Hint:      hint,
+			Retryable: false,
+		},
+	}
+}
+
+func NormalizeFormat(raw string) (Format, error) {
+	normalized := Format(strings.ToLower(strings.TrimSpace(raw)))
+	switch normalized {
+	case FormatJSON, FormatPretty, FormatNDJSON, FormatTable:
+		return normalized, nil
+	default:
+		return "", fmt.Errorf("unsupported format %q", raw)
+	}
+}
+
+func RenderSuccess(w io.Writer, format Format, jqExpr string, envelope SuccessEnvelope) error {
+	return render(w, format, jqExpr, envelope)
+}
+
+func RenderError(w io.Writer, format Format, jqExpr string, envelope ErrorEnvelope) error {
+	return render(w, format, jqExpr, envelope)
+}
+
+func render(w io.Writer, format Format, jqExpr string, envelope any) error {
+	value, err := toGeneric(envelope)
+	if err != nil {
+		return err
+	}
+	if strings.TrimSpace(jqExpr) != "" {
+		value, err = applyJQ(value, jqExpr)
+		if err != nil {
+			return err
+		}
+	}
+	return writeValue(w, format, value)
+}
+
+func toGeneric(value any) (any, error) {
+	raw, err := json.Marshal(value)
+	if err != nil {
+		return nil, err
+	}
+	var decoded any
+	if err := json.Unmarshal(raw, &decoded); err != nil {
+		return nil, err
+	}
+	return decoded, nil
+}
+
+func applyJQ(value any, expr string) (any, error) {
+	query, err := gojq.Parse(expr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid jq expression: %w", err)
+	}
+	iter := query.Run(value)
+	results := make([]any, 0)
+	for {
+		item, ok := iter.Next()
+		if !ok {
+			break
+		}
+		if jqErr, ok := item.(error); ok {
+			return nil, fmt.Errorf("jq execution failed: %w", jqErr)
+		}
+		results = append(results, item)
+	}
+	if len(results) == 0 {
+		return nil, nil
+	}
+	if len(results) == 1 {
+		return results[0], nil
+	}
+	return results, nil
+}
+
+func writeValue(w io.Writer, format Format, value any) error {
+	switch format {
+	case FormatJSON:
+		return writeJSON(w, value, true)
+	case FormatPretty:
+		return writeJSON(w, value, true)
+	case FormatNDJSON:
+		return writeNDJSON(w, value)
+	case FormatTable:
+		return writeTable(w, value)
+	default:
+		return fmt.Errorf("unsupported format %q", format)
+	}
+}
+
+func writeJSON(w io.Writer, value any, indent bool) error {
+	var (
+		raw []byte
+		err error
+	)
+	if indent {
+		raw, err = json.MarshalIndent(value, "", "  ")
+	} else {
+		raw, err = json.Marshal(value)
+	}
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(w, string(raw))
+	return err
+}
+
+func writeNDJSON(w io.Writer, value any) error {
+	if rows, ok := value.([]any); ok {
+		for _, row := range rows {
+			if err := writeJSON(w, row, false); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return writeJSON(w, value, false)
+}
+
+func writeTable(w io.Writer, value any) error {
+	value = tableViewValue(value)
+	if rows, ok := value.([]any); ok {
+		return writeTableRows(w, rows)
+	}
+	if object, ok := value.(map[string]any); ok {
+		return writeTableObject(w, object)
+	}
+	return writeJSON(w, value, true)
+}
+
+func tableViewValue(value any) any {
+	value = unwrapTableEnvelope(value)
+	if object, ok := value.(map[string]any); ok {
+		if _, hasCommand := object["command"]; hasCommand {
+			return value
+		}
+	}
+	if rows, ok := preferredTableRows(value); ok {
+		return rows
+	}
+	return value
+}
+
+func unwrapTableEnvelope(value any) any {
+	object, ok := value.(map[string]any)
+	if !ok {
+		return value
+	}
+	okValue, hasOK := object["ok"].(bool)
+	if !hasOK {
+		return value
+	}
+	if okValue {
+		if data, exists := object["data"]; exists {
+			return data
+		}
+		return value
+	}
+	if detail, exists := object["error"]; exists {
+		return detail
+	}
+	return value
+}
+
+func preferredTableRows(value any) ([]any, bool) {
+	object, ok := value.(map[string]any)
+	if !ok {
+		return nil, false
+	}
+	for _, key := range []string{"rows", "items", "messages", "members", "pages", "identities", "groups", "followers", "following", "checks", "commands"} {
+		if rows, ok := tableRows(object[key]); ok {
+			return rows, true
+		}
+	}
+	sliceKeys := make([]string, 0, len(object))
+	for key, item := range object {
+		if _, ok := tableRows(item); ok {
+			sliceKeys = append(sliceKeys, key)
+		}
+	}
+	if len(sliceKeys) != 1 {
+		return nil, false
+	}
+	return tableRows(object[sliceKeys[0]])
+}
+
+func tableRows(value any) ([]any, bool) {
+	rows, ok := value.([]any)
+	return rows, ok
+}
+
+func writeTableObject(w io.Writer, value map[string]any) error {
+	tw := tabwriter.NewWriter(w, 0, 4, 2, ' ', 0)
+	keys := make([]string, 0, len(value))
+	for key := range value {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		cell, err := tableCell(value[key])
+		if err != nil {
+			return err
+		}
+		if _, err := fmt.Fprintf(tw, "%s\t%s\n", key, cell); err != nil {
+			return err
+		}
+	}
+	return tw.Flush()
+}
+
+func writeTableRows(w io.Writer, rows []any) error {
+	if len(rows) == 0 {
+		_, err := fmt.Fprintln(w, "No rows")
+		return err
+	}
+
+	objects := make([]map[string]any, 0, len(rows))
+	columnsSet := map[string]struct{}{}
+	for _, row := range rows {
+		object, ok := row.(map[string]any)
+		if !ok {
+			return writeJSON(w, rows, true)
+		}
+		objects = append(objects, object)
+		for key := range object {
+			columnsSet[key] = struct{}{}
+		}
+	}
+
+	columns := make([]string, 0, len(columnsSet))
+	for column := range columnsSet {
+		columns = append(columns, column)
+	}
+	sort.Strings(columns)
+
+	tw := tabwriter.NewWriter(w, 0, 4, 2, ' ', 0)
+	if _, err := fmt.Fprintln(tw, strings.Join(columns, "\t")); err != nil {
+		return err
+	}
+	for _, row := range objects {
+		cells := make([]string, 0, len(columns))
+		for _, column := range columns {
+			cell, err := tableCell(row[column])
+			if err != nil {
+				return err
+			}
+			cells = append(cells, cell)
+		}
+		if _, err := fmt.Fprintln(tw, strings.Join(cells, "\t")); err != nil {
+			return err
+		}
+	}
+	return tw.Flush()
+}
+
+func tableCell(value any) (string, error) {
+	switch typed := value.(type) {
+	case nil:
+		return "", nil
+	case string:
+		return typed, nil
+	case bool, float64, float32, int, int32, int64, uint, uint32, uint64:
+		return fmt.Sprint(typed), nil
+	default:
+		buffer := bytes.NewBuffer(nil)
+		if err := writeJSON(buffer, typed, false); err != nil {
+			return "", err
+		}
+		return strings.TrimSpace(buffer.String()), nil
+	}
+}

package/internal/output/output_test.go

@@ -0,0 +1,48 @@
+package output
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestRenderSuccessTableUsesCommandDataRows(t *testing.T) {
+	t.Parallel()
+
+	envelope := SuccessEnvelope{
+		OK:      true,
+		Command: "awiki-cli msg inbox",
+		Data: map[string]any{
+			"messages": []map[string]any{
+				{
+					"id":   "msg-1",
+					"text": "hello",
+				},
+			},
+			"total":  1,
+			"source": "http",
+		},
+		Summary: "Loaded inbox",
+		Meta: Meta{
+			Version: "test",
+			Format:  string(FormatTable),
+		},
+	}
+
+	var buffer bytes.Buffer
+	if err := RenderSuccess(&buffer, FormatTable, "", envelope); err != nil {
+		t.Fatalf("RenderSuccess() error = %v", err)
+	}
+
+	rendered := buffer.String()
+	for _, forbidden := range []string{"command", "meta", "data", "ok", "awiki-cli msg inbox"} {
+		if strings.Contains(rendered, forbidden) {
+			t.Fatalf("table output %q unexpectedly contains envelope field %q", rendered, forbidden)
+		}
+	}
+	for _, want := range []string{"msg-1", "hello"} {
+		if !strings.Contains(rendered, want) {
+			t.Fatalf("table output %q does not contain row value %q", rendered, want)
+		}
+	}
+}

package/internal/runtime/config.go

@@ -0,0 +1,117 @@
+package runtime
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+)
+
+const (
+	ModeHTTP               = "http"
+	ModeWebSocket          = "websocket"
+	maxUnixSocketPathBytes = 100
+)
+
+type Resolved struct {
+	Mode       string `json:"mode"`
+	SocketPath string `json:"socket_path,omitempty"`
+}
+
+func Resolve(resolved *appconfig.Resolved) Resolved {
+	if resolved == nil {
+		return Resolved{Mode: ModeHTTP}
+	}
+	mode := strings.ToLower(strings.TrimSpace(resolved.RuntimeMode))
+	if mode != ModeWebSocket {
+		mode = ModeHTTP
+	}
+	socketPath := strings.TrimSpace(resolved.RuntimeSocketPath)
+	if socketPath == "" {
+		socketPath = filepath.Join(resolved.Paths.StateDir, "runtime", "message-daemon.sock")
+	}
+	socketPath = normalizeSocketPath(socketPath)
+	return Resolved{
+		Mode:       mode,
+		SocketPath: socketPath,
+	}
+}
+
+func IsWebSocketMode(resolved *appconfig.Resolved) bool {
+	return Resolve(resolved).Mode == ModeWebSocket
+}
+
+type BridgeRequest struct {
+	Method       string         `json:"method"`
+	Params       map[string]any `json:"params"`
+	IdentityName string         `json:"identity_name"`
+}
+
+type BridgeResponse struct {
+	OK     bool           `json:"ok"`
+	Result map[string]any `json:"result,omitempty"`
+	Error  *BridgeError   `json:"error,omitempty"`
+}
+
+type BridgeError struct {
+	Code    string `json:"code,omitempty"`
+	Message string `json:"message"`
+}
+
+func CallLocalBridge(request BridgeRequest, resolved *appconfig.Resolved) (map[string]any, error) {
+	bridge := Resolve(resolved)
+	if bridge.Mode != ModeWebSocket {
+		return nil, fmt.Errorf("runtime mode %s does not use the local websocket bridge", bridge.Mode)
+	}
+	if strings.TrimSpace(bridge.SocketPath) == "" {
+		return nil, fmt.Errorf("runtime websocket bridge socket is not configured")
+	}
+	if runtime.GOOS == "windows" {
+		return nil, fmt.Errorf("websocket bridge is not implemented on windows yet")
+	}
+	if err := os.MkdirAll(filepath.Dir(bridge.SocketPath), 0o700); err != nil {
+		return nil, fmt.Errorf("prepare websocket bridge socket dir: %w", err)
+	}
+	conn, err := net.Dial("unix", bridge.SocketPath)
+	if err != nil {
+		return nil, fmt.Errorf("local websocket bridge unavailable: %w", err)
+	}
+	defer conn.Close()
+	payload, err := json.Marshal(request)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := conn.Write(append(payload, '\n')); err != nil {
+		return nil, fmt.Errorf("write websocket bridge request: %w", err)
+	}
+	decoder := json.NewDecoder(conn)
+	var response BridgeResponse
+	if err := decoder.Decode(&response); err != nil {
+		return nil, fmt.Errorf("decode websocket bridge response: %w", err)
+	}
+	if !response.OK {
+		if response.Error == nil {
+			return nil, fmt.Errorf("local websocket bridge request failed")
+		}
+		return nil, fmt.Errorf("local websocket bridge request failed: %s", response.Error.Message)
+	}
+	if response.Result == nil {
+		return map[string]any{}, nil
+	}
+	return response.Result, nil
+}
+
+func normalizeSocketPath(path string) string {
+	if len(path) <= maxUnixSocketPathBytes {
+		return path
+	}
+	sum := sha256.Sum256([]byte(path))
+	return filepath.Join(os.TempDir(), "awiki-cli-"+hex.EncodeToString(sum[:8])+".sock")
+}

package/internal/runtime/config_test.go

@@ -0,0 +1,46 @@
+package runtime
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+)
+
+func TestResolveShortensLongSocketPath(t *testing.T) {
+	t.Parallel()
+
+	longStateDir := filepath.Join("/tmp", strings.Repeat("very-long-runtime-dir-", 10))
+	resolved := Resolve(&appconfig.Resolved{
+		RuntimeMode: "websocket",
+		Paths: appconfig.Paths{
+			StateDir: longStateDir,
+		},
+	})
+	if resolved.Mode != ModeWebSocket {
+		t.Fatalf("resolved.Mode = %q, want %q", resolved.Mode, ModeWebSocket)
+	}
+	if len(resolved.SocketPath) > maxUnixSocketPathBytes {
+		t.Fatalf("len(resolved.SocketPath) = %d, want <= %d", len(resolved.SocketPath), maxUnixSocketPathBytes)
+	}
+	if !strings.HasPrefix(resolved.SocketPath, filepath.Join(os.TempDir(), "awiki-cli-")) {
+		t.Fatalf("resolved.SocketPath = %q, want shortened temp-dir path", resolved.SocketPath)
+	}
+}
+
+func TestResolveKeepsShortSocketPath(t *testing.T) {
+	t.Parallel()
+
+	resolved := Resolve(&appconfig.Resolved{
+		RuntimeMode:       "websocket",
+		RuntimeSocketPath: "/tmp/custom-awiki.sock",
+		Paths: appconfig.Paths{
+			StateDir: "/tmp/state",
+		},
+	})
+	if resolved.SocketPath != "/tmp/custom-awiki.sock" {
+		t.Fatalf("resolved.SocketPath = %q, want /tmp/custom-awiki.sock", resolved.SocketPath)
+	}
+}

package/internal/runtime/listener/files.go

@@ -0,0 +1,65 @@
+package listener
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	appconfig "github.com/agentconnect/awiki-cli/internal/config"
+	"github.com/agentconnect/awiki-cli/internal/runtime"
+)
+
+func paths(resolved *appconfig.Resolved) (pidFile string, logFile string, statusFile string, socketPath string, err error) {
+	bridge := runtime.Resolve(resolved)
+	stateRoot := filepath.Join(resolved.Paths.StateDir, "runtime")
+	if err := os.MkdirAll(stateRoot, 0o700); err != nil {
+		return "", "", "", "", fmt.Errorf("create runtime state dir: %w", err)
+	}
+	logDir := strings.TrimSpace(resolved.Paths.LogsDir)
+	if logDir == "" {
+		logDir = stateRoot
+	}
+	if err := os.MkdirAll(logDir, 0o700); err != nil {
+		return "", "", "", "", fmt.Errorf("create runtime log dir: %w", err)
+	}
+	return filepath.Join(stateRoot, "listener.pid"),
+		filepath.Join(logDir, "listener.log"),
+		filepath.Join(stateRoot, "listener.status.json"),
+		bridge.SocketPath,
+		nil
+}
+
+func writePID(path string, pid int) error {
+	return os.WriteFile(path, []byte(strconv.Itoa(pid)), 0o600)
+}
+
+func readPID(path string) (int, error) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(strings.TrimSpace(string(raw)))
+}
+
+func writeStatus(path string, status Status) error {
+	raw, err := json.MarshalIndent(status, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, raw, 0o600)
+}
+
+func readStatus(path string) (Status, error) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return Status{}, err
+	}
+	var status Status
+	if err := json.Unmarshal(raw, &status); err != nil {
+		return Status{}, err
+	}
+	return status, nil
+}