added tasks, implemented deeplinks

Author: chiefMarlin

client/main.go

@@ -32,8 +32,9 @@ type TaskConfig struct {
 }
 
 type GoalConfig struct {
-	Prompt string `toml:"prompt"`
-	App    string `toml:"app"` // package name to launch first
+	Prompt   string `toml:"prompt"`
+	App      string `toml:"app"`      // package name to launch first
+	Deeplink string `toml:"deeplink"` // deep link URI to open (e.g. instagram://mainfeed)
 }
 
 type ModelConfig struct {
@@ -51,6 +52,7 @@ type Options struct {
 type TaskRequest struct {
 	Goal      string `json:"goal"`
 	App       string `json:"app,omitempty"`
+	Deeplink  string `json:"deeplink,omitempty"`
 	Provider  string `json:"provider,omitempty"`
 	Model     string `json:"model,omitempty"`
 	Reasoning bool   `json:"reasoning"`
@@ -91,6 +93,8 @@ func main() {
 	apiKey := flag.String("key", "", "API key (or set env var based on provider)")
 	taskFile := flag.String("task", "", "Task file (TOML)")
 	appPkg := flag.String("app", "", "App package to launch first (e.g. com.whatsapp)")
+	deeplink := flag.String("deeplink", "", "Deep link URI to open (e.g. instagram://mainfeed)")
+	deeplinksApp := flag.String("deeplinks", "", "Discover deep links for an app package (e.g. com.instagram.android)")
 	clearTasks := flag.Bool("clear", false, "Clear all tasks from server queue")
 	quiet := flag.Bool("quiet", false, "Quiet mode - minimal output for scripting")
 	showVersion := flag.Bool("version", false, "Show version and exit")
@@ -132,7 +136,50 @@ func main() {
 		os.Exit(0)
 	}
 
-	var goal, prov, mod, app string
+	// Handle -deeplinks flag: discover deep links for an app
+	if *deeplinksApp != "" {
+		dlReq, _ := http.NewRequest("GET", *server+"/deeplinks?app="+*deeplinksApp, nil)
+		if srvKey != "" {
+			dlReq.Header.Set("X-Server-Key", srvKey)
+		}
+		dlResp, err := http.DefaultClient.Do(dlReq)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+		defer func() { _ = dlResp.Body.Close() }()
+
+		if dlResp.StatusCode != http.StatusOK {
+			var errResp ErrorResponse
+			bodyBytes, _ := io.ReadAll(dlResp.Body)
+			if json.Unmarshal(bodyBytes, &errResp) == nil && errResp.Error != "" {
+				fmt.Fprintf(os.Stderr, "Error: %s\n", errResp.Error)
+			} else {
+				fmt.Fprintf(os.Stderr, "Error: %s\n", string(bodyBytes))
+			}
+			os.Exit(1)
+		}
+
+		var dlResult struct {
+			App       string   `json:"app"`
+			Deeplinks []string `json:"deeplinks"`
+		}
+		if err := json.NewDecoder(dlResp.Body).Decode(&dlResult); err != nil {
+			fmt.Fprintf(os.Stderr, "Error decoding response: %v\n", err)
+			os.Exit(1)
+		}
+
+		fmt.Printf("Deep links for %s:\n", dlResult.App)
+		if len(dlResult.Deeplinks) == 0 {
+			fmt.Println("  (none found)")
+		}
+		for _, dl := range dlResult.Deeplinks {
+			fmt.Printf("  %s\n", dl)
+		}
+		os.Exit(0)
+	}
+
+	var goal, prov, mod, app, dl string
 	var reason, vis bool
 	var steps int
 
@@ -146,6 +193,7 @@ func main() {
 
 		goal = tf.Task.Goal.Prompt
 		app = tf.Task.Goal.App
+		dl = tf.Task.Goal.Deeplink
 		prov = tf.Task.Model.Provider
 		mod = tf.Task.Model.Model
 		reason = tf.Task.Options.Reasoning
@@ -191,6 +239,9 @@ func main() {
 	if *appPkg != "" {
 		app = *appPkg
 	}
+	if *deeplink != "" {
+		dl = *deeplink
+	}
 
 	// Get API key from flag or env
 	key := *apiKey
@@ -220,13 +271,17 @@ func main() {
 		if app != "" {
 			fmt.Printf("App:     %s\n", app)
 		}
+		if dl != "" {
+			fmt.Printf("Link:    %s\n", dl)
+		}
 		fmt.Printf("Goal:    %s\n\n", truncate(goal, 60))
 	}
 
 	// Submit task (without API key in body)
 	req := TaskRequest{
 		Goal:      goal,
 		App:       app,
+		Deeplink:  dl,
 		Provider:  prov,
 		Model:     mod,
 		Reasoning: reason,

server/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bufio"
 	"context"
 	"crypto/rand"
 	"encoding/hex"
@@ -9,8 +10,10 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"os/exec"
 	"os/signal"
 	"regexp"
+	"sort"
 	"strings"
 	"syscall"
 	"time"
@@ -104,6 +107,7 @@ func NewAPI(q *Queue) *API {
 	a.mux.HandleFunc("/run", a.handleRun)
 	a.mux.HandleFunc("/task/", a.handleTask)
 	a.mux.HandleFunc("/queue", a.handleQueue)
+	a.mux.HandleFunc("/deeplinks", a.handleDeeplinks)
 	a.mux.HandleFunc("/health", a.handleHealth)
 	return a
 }
@@ -250,6 +254,13 @@ func validateRequest(req *TaskRequest, apiKey string) error {
 		}
 	}
 
+	// Deeplink validation (if provided): must be a non-empty URI with a scheme
+	if req.Deeplink != "" {
+		if !strings.Contains(req.Deeplink, "://") {
+			return fmt.Errorf("invalid deeplink (must contain ://): %s", req.Deeplink)
+		}
+	}
+
 	return nil
 }
 
@@ -314,6 +325,129 @@ func (a *API) handleQueue(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func (a *API) handleDeeplinks(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+
+	app := r.URL.Query().Get("app")
+	if app == "" {
+		writeError(w, "app query parameter is required", http.StatusBadRequest)
+		return
+	}
+
+	// Validate package name
+	matched, _ := regexp.MatchString(`^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$`, app)
+	if !matched {
+		writeError(w, "invalid app package name: "+app, http.StatusBadRequest)
+		return
+	}
+
+	// Run adb shell dumpsys package
+	cmd := exec.Command("adb", "shell", "dumpsys", "package", app)
+	out, err := cmd.Output()
+	if err != nil {
+		writeError(w, "adb error: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	deeplinks := parseDeeplinks(string(out))
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(map[string]any{
+		"app":       app,
+		"deeplinks": deeplinks,
+	}); err != nil {
+		log.Printf("Failed to encode deeplinks response: %v", err)
+	}
+}
+
+// parseDeeplinks extracts non-http/https deep link URIs from `dumpsys package` output.
+// It scans for intent-filter blocks, collects schemes and authorities per block,
+// then combines them into scheme://authority URIs.
+func parseDeeplinks(output string) []string {
+	seen := make(map[string]bool)
+	var schemes []string
+	var authorities []string
+
+	scanner := bufio.NewScanner(strings.NewReader(output))
+	inFilter := false
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Detect intent-filter block boundaries
+		if strings.Contains(line, "filter") {
+			// Emit combinations from previous block
+			for _, s := range schemes {
+				if len(authorities) == 0 {
+					uri := s + "://"
+					if !seen[uri] {
+						seen[uri] = true
+					}
+				}
+				for _, a := range authorities {
+					uri := s + "://" + a
+					if !seen[uri] {
+						seen[uri] = true
+					}
+				}
+			}
+			schemes = nil
+			authorities = nil
+			inFilter = true
+			continue
+		}
+
+		if !inFilter {
+			continue
+		}
+
+		// Collect schemes (skip http and https)
+		if strings.HasPrefix(line, "Scheme: \"") {
+			scheme := strings.TrimPrefix(line, "Scheme: \"")
+			scheme = strings.TrimSuffix(scheme, "\"")
+			if scheme != "http" && scheme != "https" {
+				schemes = append(schemes, scheme)
+			}
+		}
+
+		// Collect authorities: format is Authority: "host": -1 (or similar port)
+		if strings.HasPrefix(line, "Authority: \"") {
+			rest := strings.TrimPrefix(line, "Authority: \"")
+			if idx := strings.Index(rest, "\""); idx >= 0 {
+				authority := rest[:idx]
+				authorities = append(authorities, authority)
+			}
+		}
+	}
+
+	// Emit final block
+	for _, s := range schemes {
+		if len(authorities) == 0 {
+			uri := s + "://"
+			if !seen[uri] {
+				seen[uri] = true
+			}
+		}
+		for _, a := range authorities {
+			uri := s + "://" + a
+			if !seen[uri] {
+				seen[uri] = true
+			}
+		}
+	}
+
+	// Collect and sort
+	var result []string
+	for uri := range seen {
+		result = append(result, uri)
+	}
+	sort.Strings(result)
+	return result
+}
+
 func generateRequestID() string {
 	b := make([]byte, 8)
 	if _, err := rand.Read(b); err != nil {

server/queue.go

@@ -16,6 +16,7 @@ import (
 type TaskRequest struct {
 	Goal      string `json:"goal"`
 	App       string `json:"app,omitempty"`
+	Deeplink  string `json:"deeplink,omitempty"`
 	Provider  string `json:"provider"`
 	Model     string `json:"model"`
 	Reasoning bool   `json:"reasoning"`
@@ -29,6 +30,7 @@ type TaskRequest struct {
 type TaskRequestSafe struct {
 	Goal      string `json:"goal"`
 	App       string `json:"app,omitempty"`
+	Deeplink  string `json:"deeplink,omitempty"`
 	Provider  string `json:"provider"`
 	Model     string `json:"model"`
 	Reasoning bool   `json:"reasoning"`
@@ -89,6 +91,7 @@ func (q *Queue) Submit(req TaskRequest, apiKey string) *Task {
 		Request: TaskRequestSafe{
 			Goal:      req.Goal,
 			App:       req.App,
+			Deeplink:  req.Deeplink,
 			Provider:  req.Provider,
 			Model:     req.Model,
 			Reasoning: req.Reasoning,
@@ -230,6 +233,7 @@ func (q *Queue) process(id string) {
 	input, _ := json.Marshal(map[string]any{
 		"goal":      task.Request.Goal,
 		"app":       task.Request.App,
+		"deeplink":  task.Request.Deeplink,
 		"provider":  task.Request.Provider,
 		"model":     task.Request.Model,
 		"reasoning": task.Request.Reasoning,

tasks/get-notifications.toml

@@ -0,0 +1,32 @@
+# Get all unread notifications task
+
+[task]
+name = "get-notifications"
+description = "Report all unread notifications without clearing them"
+
+[task.goal]
+app = ""
+prompt = """
+1. Pull down the notification shade from the top of the screen (swipe down from the status bar)
+2. Read ALL notifications currently visible in the notification shade
+3. For each notification, capture:
+   - App name (the source app)
+   - Title/header text
+   - Body/content text
+   - Time if visible
+4. If there are grouped notifications, expand them to see all individual notifications
+5. DO NOT clear, dismiss, or interact with any notifications - just read them
+6. DO NOT tap on any notification
+7. Close the notification shade (swipe up or tap outside)
+8. Return to home screen
+9. Report a complete list of all notifications found with their details
+"""
+
+[task.model]
+provider = "Google"
+model = "gemini-flash-latest"
+
+[task.options]
+reasoning = true
+vision = true
+max_steps = 15

tasks/instagram-reply.toml

@@ -0,0 +1,38 @@
+# Instagram notification reply task
+
+[task]
+name = "instagram-reply"
+description = "Check unread Instagram notifications for comments or likes and reply to them"
+
+[task.goal]
+app = ""
+prompt = """
+1. Pull down the notification shade by swiping down from the very top of the screen
+2. Look through the phone notifications for any from Instagram about:
+   - Comments on your posts
+   - Likes on your posts
+3. For each Instagram COMMENT notification:
+   - Tap on the notification to open it directly in Instagram
+   - Read the comment to understand context
+   - Reply to the comment with a friendly, relevant response
+   - Pull down the notification shade again to continue with the next notification
+4. For each Instagram LIKE notification:
+   - Note who liked your post from the notification text
+   - Do NOT tap on it, just skip to the next notification
+5. Skip any notifications that are NOT from Instagram, and skip Instagram notifications
+   that are about follows, suggestions, or ads
+6. After processing all Instagram notifications, close the notification shade
+7. Report a summary of:
+   - How many comment notifications were found
+   - How many like notifications were found
+   - What replies you sent and to which comments
+"""
+
+[task.model]
+provider = "Google"
+model = "gemini-flash-latest"
+
+[task.options]
+reasoning = true
+vision = true
+max_steps = 30