21978860214

Committed 13 Feb 2026 07:45AM UTC coverage: 5.772% (+0.008%) from 5.764%

Build # 21978860214

Build Type

push

github

Committed by chaoyuepan

Commit Message

improve web fetch

Run Details

4 of 24 new or added lines in 10 files covered. (16.67%)

221 existing lines in 4 files now uncovered.

1517 of 26284 relevant lines covered (5.77%)

0.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/skills/install_node.go

package skills

import (
        "context"
        "fmt"
        "strings"
)

// NodeInstaller implements Node.js package installations
type NodeInstaller struct {
        // NodeManager is the package manager to use (npm, pnpm, yarn, or bun)
        NodeManager string
}

var (
        // Supported node managers
        nodeManagers = []string{"npm", "pnpm", "yarn", "bun"}
)

// CanInstall checks if the configured node manager is available
func (n *NodeInstaller) CanInstall(spec *SkillInstallSpec) bool {
        if spec.Kind != "node" {
                return false
        }
        manager := n.resolveManager()
        return manager != "" && spec.Package != ""
}

// Install installs a package using the configured node manager
func (n *NodeInstaller) Install(ctx context.Context, spec *SkillInstallSpec) InstallResult {
        manager := n.resolveManager()
        if manager == "" {
                return InstallResult{
                        Success: false,
                        Message: "node manager not available (install npm, pnpm, yarn, or bun)",
                }
        }

        // Validate package
        if spec.Package == "" {
                return InstallResult{
                        Success: false,
                        Message: "missing node package",
                }
        }

        // Check if already installed
        if !spec.Extract {
                isInstalled := n.isInstalled(ctx, manager, spec.Package)
                if isInstalled {
                        return InstallResult{
                                Success: true,
                                Message: fmt.Sprintf("Already installed: %s", spec.Package),
                        }
                }
        }

        // Build command
        argv := n.buildCommand(spec.Package)

        // Run installation
        stdout, stderr, exitCode, _ := RunCommandWithTimeout(ctx, argv, nil)

        success := exitCode != nil && *exitCode == 0
        var message string
        if success {
                message = fmt.Sprintf("Installed: %s (%s)", spec.Package, manager)
        } else {
                message = FormatInstallFailureMessage(stdout, stderr, exitCode)
        }

        return InstallResult{
                Success:  success,
                Message:  message,
                Stdout:   stdout,
                Stderr:   stderr,
                ExitCode: exitCode,
        }
}

// resolveManager returns the best available node manager
func (n *NodeInstaller) resolveManager() string {
        // Use configured manager if available
        if n.NodeManager != "" && HasBinary(n.NodeManager) {
                return n.NodeManager
        }

        // Try preferred managers in order
        for _, manager := range nodeManagers {
                if HasBinary(manager) {
                        return manager
                }
        }

        return ""
}

// buildCommand builds the install command for a package
func (n *NodeInstaller) buildCommand(pkg string) []string {
        manager := n.resolveManager()

        switch manager {
        case "pnpm":
                return []string{"pnpm", "add", "-g", pkg}
        case "yarn":
                return []string{"yarn", "global", "add", pkg}
        case "bun":
                return []string{"bun", "add", "-g", pkg}
        default: // npm
                return []string{"npm", "install", "-g", pkg}
        }
}

// isInstalled checks if a package is installed globally
func (n *NodeInstaller) isInstalled(ctx context.Context, _, pkg string) bool {
        manager := n.resolveManager()

        var argv []string
        switch manager {
        case "pnpm":
                argv = []string{manager, "list", "-g", "--depth=0"}
        case "yarn":
                argv = []string{manager, "global", "list"}
        case "bun":
                argv = []string{manager, "pm", "ls", "-g"}
        default: // npm
                argv = []string{manager, "list", "-g", "--depth=0"}
        }

        stdout, _, _, _ := RunCommandWithTimeout(ctx, argv, nil)

        // Check if package appears in the list
        output := strings.ToLower(stdout)
        // For global packages, npm lists them as "package@version"
        // or just "package" depending on the npm version and flags
        search := strings.ToLower(pkg)
        return strings.Contains(output, search+"@") || strings.Contains(output, " "+search+" ") ||
                strings.Contains(output, search+"\n")
}

1	package skills
2
3	import (
4	"context"
5	"fmt"
6	"strings"
7	)
8
9	// NodeInstaller implements Node.js package installations
10	type NodeInstaller struct {
11	// NodeManager is the package manager to use (npm, pnpm, yarn, or bun)
12	NodeManager string
13	}
14
15	var (
16	// Supported node managers
17	nodeManagers = []string{"npm", "pnpm", "yarn", "bun"}
18	)
19
20	// CanInstall checks if the configured node manager is available
21	func (n NodeInstaller) CanInstall(spec SkillInstallSpec) bool {	×
22	if spec.Kind != "node" {	×
23	return false	×
24	}	×
25	manager := n.resolveManager()	×
26	return manager != "" && spec.Package != ""	×
27	}
28
29	// Install installs a package using the configured node manager
30	func (n NodeInstaller) Install(ctx context.Context, spec SkillInstallSpec) InstallResult {	×
31	manager := n.resolveManager()	×
32	if manager == "" {	×
33	return InstallResult{	×
34	Success: false,	×
35	Message: "node manager not available (install npm, pnpm, yarn, or bun)",	×
36	}	×
37	}	×
38
39	// Validate package
40	if spec.Package == "" {	×
41	return InstallResult{	×
42	Success: false,	×
43	Message: "missing node package",	×
44	}	×
45	}	×
46
47	// Check if already installed
48	if !spec.Extract {	×
49	isInstalled := n.isInstalled(ctx, manager, spec.Package)	×
50	if isInstalled {	×
51	return InstallResult{	×
52	Success: true,	×
53	Message: fmt.Sprintf("Already installed: %s", spec.Package),	×
54	}	×
55	}	×
56	}
57
58	// Build command
59	argv := n.buildCommand(spec.Package)	×
60		×
61	// Run installation	×
62	stdout, stderr, exitCode, _ := RunCommandWithTimeout(ctx, argv, nil)	×
63		×
64	success := exitCode != nil && *exitCode == 0	×
65	var message string	×
66	if success {	×
67	message = fmt.Sprintf("Installed: %s (%s)", spec.Package, manager)	×
68	} else {	×
69	message = FormatInstallFailureMessage(stdout, stderr, exitCode)	×
70	}	×
71
72	return InstallResult{	×
73	Success: success,	×
74	Message: message,	×
75	Stdout: stdout,	×
76	Stderr: stderr,	×
77	ExitCode: exitCode,	×
78	}	×
79	}
80
81	// resolveManager returns the best available node manager
82	func (n *NodeInstaller) resolveManager() string {	×
83	// Use configured manager if available	×
84	if n.NodeManager != "" && HasBinary(n.NodeManager) {	×
85	return n.NodeManager	×
86	}	×
87
88	// Try preferred managers in order
89	for _, manager := range nodeManagers {	×
90	if HasBinary(manager) {	×
91	return manager	×
92	}	×
93	}
94
95	return ""	×
96	}
97
98	// buildCommand builds the install command for a package
99	func (n *NodeInstaller) buildCommand(pkg string) []string {	×
100	manager := n.resolveManager()	×
101		×
102	switch manager {	×
103	case "pnpm":	×
104	return []string{"pnpm", "add", "-g", pkg}	×
105	case "yarn":	×
106	return []string{"yarn", "global", "add", pkg}	×
107	case "bun":	×
108	return []string{"bun", "add", "-g", pkg}	×
109	default: // npm	×
110	return []string{"npm", "install", "-g", pkg}	×
111	}
112	}
113
114	// isInstalled checks if a package is installed globally
NEW 115	func (n *NodeInstaller) isInstalled(ctx context.Context, _, pkg string) bool {	×
NEW 116	manager := n.resolveManager()	×
117		×
118	var argv []string	×
119	switch manager {	×
120	case "pnpm":	×
121	argv = []string{manager, "list", "-g", "--depth=0"}	×
122	case "yarn":	×
123	argv = []string{manager, "global", "list"}	×
124	case "bun":	×
125	argv = []string{manager, "pm", "ls", "-g"}	×
126	default: // npm	×
127	argv = []string{manager, "list", "-g", "--depth=0"}	×
128	}
129
130	stdout, _, _, _ := RunCommandWithTimeout(ctx, argv, nil)	×
131		×
132	// Check if package appears in the list	×
133	output := strings.ToLower(stdout)	×
134	// For global packages, npm lists them as "package@version"	×
135	// or just "package" depending on the npm version and flags	×
136	search := strings.ToLower(pkg)	×
137	return strings.Contains(output, search+"@") \|\| strings.Contains(output, " "+search+" ") \|\|	×
138	strings.Contains(output, search+"\n")	×
139	}

smallnest / goclaw / 21978860214

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous