Release CLI 0.1.12

Author: michaelzixizhou

README.md

@@ -146,10 +146,11 @@ CODAG_CONSOLE=http://localhost:3000 codag auth login
 After `codag setup`, supported agents can call Codag tools directly instead of
 fetching raw logs through shell commands. For example, an agent can call
 `tail_kubernetes`, `tail_aws_logs`, or the generic `wrap` tool and receive a
-deterministic compact summary instead of thousands of raw log lines.
+compact summary instead of thousands of raw log lines.
 
-MCP log tools use the hosted deterministic compact path directly. They do not
-call the authenticated capsule/parse inference endpoints.
+MCP log tools use the same compact endpoint as `codag wrap`: signed-in
+workspaces follow the Free/Pro plan, and signed-out tools fall back to the
+hosted deterministic Free path.
 
 If your Codag org runs out of credits or needs a billing action, MCP tool errors
 include a stable marker such as `CODAG_CREDITS_EXHAUSTED` and tell the agent to
@@ -162,11 +163,14 @@ to the configured Codag API server for compression. Provider credentials used by
 local source connectors stay in your local Codag config unless a provider API
 request itself requires them.
 
-When you are not signed in, `codag wrap` in the default compact mode falls back
-to the hosted free deterministic templating path. The CLI mints and stores a
-server-issued anonymous `cda_...` token, calls `/v1/free/compact`, and reuses the
-token until you log in. Anonymous `--mode capsule` and `--mode parse` still
-require login because those modes use the authenticated inference pipeline.
+When you are signed in, `codag wrap` in the default compact mode uses the current
+workspace plan: Codag Free returns deterministic compaction, and Codag Pro
+returns the hosted inference compaction path with deterministic fallback. When
+you are not signed in, compact mode falls back to the hosted free deterministic
+path. The CLI mints and stores a server-issued anonymous `cda_...` token, calls
+`/v1/free/compact`, and reuses the token until you log in. Anonymous
+`--mode capsule` and `--mode parse` still require login and Codag Pro because
+those modes use the authenticated inference pipeline.
 
 Use `CODAG_SERVER` or `codag config set server <url>` to point the CLI at a
 self-hosted, staging, or local API.

cmd/config.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/codag-megalith/codag-cli/internal/config"
+	"github.com/codag-megalith/codag-cli/internal/setup"
 	"github.com/spf13/cobra"
 )
 
@@ -17,14 +18,22 @@ var configCmd = &cobra.Command{
 
 var configSetCmd = &cobra.Command{
 	Use:   "set <key> <value>",
-	Short: "Set a config value (server, telemetry, updates)",
-	Args:  cobra.ExactArgs(2),
-	RunE:  runConfigSet,
+	Short: "Set a config value (server, telemetry, updates, <provider>.<field>)",
+	Long: `Set a config value.
+
+Top-level keys: server, telemetry, updates.
+
+Provider credentials use a <provider>.<field> key, e.g.:
+  codag config set datadog.api_key <value>
+  codag config set sentry.auth_token <value>
+This is the non-interactive equivalent of the provider prompts in ` + "`codag setup`" + `.`,
+	Args: cobra.ExactArgs(2),
+	RunE: runConfigSet,
 }
 
 var configGetCmd = &cobra.Command{
 	Use:   "get <key>",
-	Short: "Print a config value (server, telemetry, updates)",
+	Short: "Print a config value (server, telemetry, updates, <provider>.<field>)",
 	Args:  cobra.ExactArgs(1),
 	RunE:  runConfigGet,
 }
@@ -48,6 +57,18 @@ func runConfigSet(_ *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	// `<provider>.<field>` routes to per-provider credentials (datadog.api_key,
+	// sentry.auth_token, …) — the scriptable equivalent of `codag setup`.
+	if provider, field, ok := strings.Cut(key, "."); ok {
+		if err := setup.SetProviderField(c, provider, field, val); err != nil {
+			return err
+		}
+		if err := config.Save(c); err != nil {
+			return err
+		}
+		fmt.Fprintf(os.Stderr, "saved %s -> %s\n", key, config.ConfigPath())
+		return nil
+	}
 	switch key {
 	case "server":
 		c.Server = val
@@ -72,7 +93,7 @@ func runConfigSet(_ *cobra.Command, args []string) error {
 	case "api-key", "api_key":
 		return fmt.Errorf("api-key is no longer supported; sign in with `codag auth login`")
 	default:
-		return fmt.Errorf("unknown key %q (valid: server, telemetry, updates)", key)
+		return fmt.Errorf("unknown key %q (valid: server, telemetry, updates, or <provider>.<field> such as datadog.api_key)", key)
 	}
 	if err := config.Save(c); err != nil {
 		return err
@@ -87,6 +108,16 @@ func runConfigGet(_ *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	// `<provider>.<field>` reads per-provider credentials. Secret fields
+	// (api_key, auth_token, …) are masked; host/org print in full.
+	if provider, field, ok := strings.Cut(key, "."); ok {
+		v, err := setup.DescribeProviderField(c, provider, field)
+		if err != nil {
+			return err
+		}
+		fmt.Println(v)
+		return nil
+	}
 	switch key {
 	case "server":
 		fmt.Println(c.Server)
@@ -105,7 +136,7 @@ func runConfigGet(_ *cobra.Command, args []string) error {
 	case "api-key", "api_key":
 		return fmt.Errorf("api-key is no longer supported; sign in with `codag auth login`")
 	default:
-		return fmt.Errorf("unknown key %q (valid: server, telemetry, updates)", key)
+		return fmt.Errorf("unknown key %q (valid: server, telemetry, updates, or <provider>.<field> such as datadog.api_key)", key)
 	}
 	return nil
 }

cmd/help_llm.go

@@ -37,8 +37,9 @@ If codag MCP tools are available:
 - Use ` + "`wrap`" + ` for local files and provider CLIs without a named tool.
 - Use ` + "`compact`" + ` only for log text that is already in chat or returned by another
   tool and cannot be fetched from disk/provider CLI.
-- MCP log tools return deterministic compact summaries; they do not use the
-  authenticated capsule/parse inference endpoints.
+- MCP log tools return compact summaries. If the user is signed in, they follow
+  the workspace Free/Pro plan. If not signed in, compact falls back to hosted
+  Free deterministic compaction.
 
 ## CLI fallback patterns
 
@@ -58,11 +59,11 @@ If codag MCP tools are available:
 
 ## Output modes
 
-- ` + "`compact`" + `   Default. Plain-text deterministic compact summary with
-  severity, services, and representative evidence.
-  Best for pasting directly back into your reasoning.
-- ` + "`capsule`" + `   IncidentCapsule JSON. Use when you need structured fields.
-- ` + "`parse`" + `     Just the unique templates. Use when you want the patterns only.
+- ` + "`compact`" + `   Default. Plan-aware when signed in: Codag Free returns
+  deterministic compaction; Codag Pro returns the inference evidence-board path
+  with deterministic fallback. Anonymous compact uses hosted Free.
+- ` + "`capsule`" + `   IncidentCapsule JSON. Requires login and Codag Pro.
+- ` + "`parse`" + `     Just the unique templates. Requires login and Codag Pro.
 
 ## Useful flags
 
@@ -87,9 +88,10 @@ Use it to confirm compression worked.
 - Exit code 1 + ` + "`error: ...`" + ` on stderr if the API is unreachable or rejected
   the request. Pass ` + "`--server`" + ` to override the configured server URL,
   or run ` + "`codag auth login`" + ` if the server says you're not signed in.
-- If an MCP tool returns ` + "`CODAG_CREDITS_EXHAUSTED`" + ` or ` + "`CODAG_BILLING_REQUIRED`" + `,
-  tell the user to upgrade/manage billing, or run ` + "`codag disable`" + ` to remove
-  codag MCP tools from their agents.
+- If a tool returns ` + "`CODAG_PRO_REQUIRED`" + `, ` + "`CODAG_CREDITS_EXHAUSTED`" + `, or
+  ` + "`CODAG_BILLING_REQUIRED`" + `, tell the user to open Billing, upgrade/manage the
+  workspace plan, or run ` + "`codag disable`" + ` to remove codag MCP tools from
+  their agents.
 - The wrapped child's exit code is propagated, so wrapping a failing command
   still surfaces the failure.
 

cmd/root.go

@@ -13,7 +13,7 @@ import (
 )
 
 var (
-	Version   = "0.1.8"
+	Version   = "0.1.12"
 	Commit    = "none"
 	BuildDate = "unknown"
 )

cmd/telemetry.go

@@ -25,6 +25,8 @@ func addTelemetryError(props map[string]any, err error) {
 		code = "unauthenticated"
 	case errors.Is(err, api.ErrQuotaExceeded):
 		code = "quota_exceeded"
+	case errors.Is(err, api.ErrOverloaded):
+		code = "overloaded"
 	case errors.As(err, &httpErr):
 		code = "http_error"
 		props["http_status"] = httpErr.Status

cmd/telemetry_test.go

@@ -48,6 +48,13 @@ func TestAddTelemetryErrorClassifiesKnownSentinels(t *testing.T) {
 	if got := props["error_code"]; got != "quota_exceeded" {
 		t.Fatalf("error_code = %v, want quota_exceeded", got)
 	}
+
+	props = map[string]any{}
+	addTelemetryError(props, fmt.Errorf("wrapped: %w", api.ErrOverloaded))
+
+	if got := props["error_code"]; got != "overloaded" {
+		t.Fatalf("error_code = %v, want overloaded", got)
+	}
 }
 
 func TestAddTelemetryErrorCapturesChildExitCode(t *testing.T) {

cmd/wrap.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/codag-megalith/codag-cli/internal/analytics"
 	"github.com/codag-megalith/codag-cli/internal/api"
+	"github.com/codag-megalith/codag-cli/internal/config"
 	childexec "github.com/codag-megalith/codag-cli/internal/exec"
 	"github.com/codag-megalith/codag-cli/internal/source"
 	"github.com/spf13/cobra"
@@ -101,6 +102,16 @@ func wrapAuthRequiredError(mode string) error {
 	return fmt.Errorf("--mode %s needs a signed-in Codag account.\n\nRun:\n  codag auth login\n\nThen retry:\n  codag wrap --mode %s -- <your log command>\n\nIf you only need the compact summary, omit --mode %s; default compact mode works without login:\n  codag wrap -- <your log command>", mode, mode, mode)
 }
 
+func wrapProRequiredError(mode string, upgradePath string) error {
+	if upgradePath == "" {
+		upgradePath = "/dashboard/billing"
+	}
+	if !strings.HasPrefix(upgradePath, "http://") && !strings.HasPrefix(upgradePath, "https://") {
+		upgradePath = strings.TrimRight(config.ResolveConsole(), "/") + "/" + strings.TrimLeft(upgradePath, "/")
+	}
+	return fmt.Errorf("--mode %s needs Codag Pro for this workspace.\n\nOpen Billing:\n  %s\n\nThen retry:\n  codag wrap --mode %s -- <your log command>\n\nIf you only need the compact summary, omit --mode %s; default compact mode uses Free or Pro based on the workspace plan:\n  codag wrap -- <your log command>", mode, upgradePath, mode, mode)
+}
+
 func init() {
 	wrapCmd.Flags().String("service", "", "Service tag for these lines")
 	wrapCmd.Flags().String("source", "", "Where the logs came from (auto-detected from the wrapped command; e.g. railway, vercel, kubectl). Override to label explicitly.")
@@ -232,6 +243,10 @@ func runWrap(cmd *cobra.Command, args []string) error {
 
 	if apiErr != nil {
 		analytics.Capture("cli_wrap_failed", wrapEventProps(mode, hadChild, inToks, 0, time.Since(wrapStart), len(lines), apiErr))
+		var billingErr *api.BillingError
+		if errors.As(apiErr, &billingErr) && billingErr.Detail == "pro_required" {
+			return wrapProRequiredError(mode, billingErr.UpgradePath)
+		}
 		if errors.Is(apiErr, api.ErrUnauthenticated) {
 			switch mode {
 			case "capsule":
@@ -279,6 +294,7 @@ func wrapEventProps(mode string, hadChild bool, inToks, outToks int, dur time.Du
 	props := map[string]any{
 		"mode":         mode,
 		"input_kind":   "stdin",
+		"line_count":   lineCount,
 		"input_lines":  lineCount,
 		"input_tokens": inToks,
 		"duration_ms":  dur.Milliseconds(),

cmd/wrap_test.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestWrapNoInputErrorTeachesHappyPath(t *testing.T) {
@@ -36,6 +37,21 @@ func TestWrapAuthRequiredErrorOffersCompactFallback(t *testing.T) {
 	}
 }
 
+func TestWrapProRequiredErrorLinksBilling(t *testing.T) {
+	t.Setenv("CODAG_CONSOLE", "https://console.example.test")
+	msg := wrapProRequiredError("parse", "/dashboard/billing").Error()
+	for _, want := range []string{
+		"--mode parse needs Codag Pro",
+		"https://console.example.test/dashboard/billing",
+		"codag wrap --mode parse -- <your log command>",
+		"default compact mode uses Free or Pro",
+	} {
+		if !strings.Contains(msg, want) {
+			t.Fatalf("pro error missing %q in:\n%s", want, msg)
+		}
+	}
+}
+
 func TestWrapHelpDistinguishesCompactAndCapsule(t *testing.T) {
 	if strings.Contains(wrapCmd.Short, "incident capsule") {
 		t.Fatalf("wrap short help still says incident capsule: %q", wrapCmd.Short)
@@ -51,3 +67,16 @@ func TestWrapHelpDistinguishesCompactAndCapsule(t *testing.T) {
 		}
 	}
 }
+
+func TestWrapEventPropsIncludesCanonicalLineCount(t *testing.T) {
+	props := wrapEventProps("compact", true, 100, 25, 50*time.Millisecond, 7, nil)
+	if props["line_count"] != 7 {
+		t.Fatalf("line_count = %v, want 7", props["line_count"])
+	}
+	if props["input_lines"] != 7 {
+		t.Fatalf("input_lines = %v, want 7", props["input_lines"])
+	}
+	if props["input_kind"] != "child" {
+		t.Fatalf("input_kind = %v, want child", props["input_kind"])
+	}
+}

internal/api/client.go

@@ -29,6 +29,10 @@ var ErrUnauthenticated = errors.New("not signed in (or refresh failed); run `cod
 // quota count) is preserved for users who need the exact number.
 var ErrQuotaExceeded = errors.New("warm quota exceeded for today")
 
+// ErrOverloaded is returned when Codag is temporarily unable to accept more
+// synchronous work. This is retryable and distinct from billing/quota.
+var ErrOverloaded = errors.New("codag is busy; retry later")
+
 // ErrBillingRequired is returned when the server blocks a metered call
 // because the org needs a billing action: out of included credits,
 // subscription past due, etc. Callers should surface a clear upgrade path
@@ -43,6 +47,34 @@ type BillingError struct {
 	Body        string
 }
 
+// RateLimitError carries the machine-readable detail and Retry-After hint from
+// a 429 that is not a warm quota exhaustion.
+type RateLimitError struct {
+	Detail     string
+	RetryAfter string
+	Body       string
+}
+
+func (e *RateLimitError) Error() string {
+	if e == nil {
+		return ErrOverloaded.Error()
+	}
+	if e.RetryAfter != "" {
+		return fmt.Sprintf("%s: retry after %s seconds", ErrOverloaded, e.RetryAfter)
+	}
+	if e.Detail != "" {
+		return fmt.Sprintf("%s: %s", ErrOverloaded, e.Detail)
+	}
+	if e.Body != "" {
+		return fmt.Sprintf("%s: %s", ErrOverloaded, e.Body)
+	}
+	return ErrOverloaded.Error()
+}
+
+func (e *RateLimitError) Unwrap() error {
+	return ErrOverloaded
+}
+
 func (e *BillingError) Error() string {
 	if e == nil {
 		return ErrBillingRequired.Error()
@@ -135,8 +167,11 @@ type CapsuleResponse struct {
 }
 
 type CompactResponse struct {
-	Text  string `json:"text"`
-	Stats Stats  `json:"stats"`
+	Text            string `json:"text"`
+	Stats           Stats  `json:"stats"`
+	CompactEngine   string `json:"compact_engine,omitempty"`
+	CompactFallback string `json:"compact_fallback,omitempty"`
+	CompactError    string `json:"compact_error,omitempty"`
 }
 
 type AnonymousTokenResponse struct {
@@ -328,8 +363,7 @@ func (c *Client) do(method, path string, body any, out any) error {
 			}
 		}
 		if resp.StatusCode == http.StatusTooManyRequests {
-			// Wrap with the sentinel so callers can errors.Is(err, ErrQuotaExceeded).
-			return fmt.Errorf("%w: %s", ErrQuotaExceeded, body)
+			return rateLimitError(resp, body)
 		}
 		return &HTTPError{Status: resp.StatusCode, Body: body}
 	}
@@ -446,7 +480,7 @@ func decodeHTTPResponse(resp *http.Response, respBody []byte, out any) error {
 			}
 		}
 		if resp.StatusCode == http.StatusTooManyRequests {
-			return fmt.Errorf("%w: %s", ErrQuotaExceeded, body)
+			return rateLimitError(resp, body)
 		}
 		return &HTTPError{Status: resp.StatusCode, Body: body}
 	}
@@ -468,6 +502,18 @@ func responseDetail(body string) string {
 	return body
 }
 
+func rateLimitError(resp *http.Response, body string) error {
+	detail := responseDetail(body)
+	if strings.Contains(strings.ToLower(detail), "quota") {
+		return fmt.Errorf("%w: %s", ErrQuotaExceeded, body)
+	}
+	return &RateLimitError{
+		Detail:     detail,
+		RetryAfter: resp.Header.Get("Retry-After"),
+		Body:       body,
+	}
+}
+
 func readBody(r io.Reader, limit int64) ([]byte, error) {
 	body, err := io.ReadAll(io.LimitReader(r, limit+1))
 	if err != nil {