@synopackageland/cli 0.5.0 → 0.6.0

package/dist/templates/_executor/watch_test.go

@@ -0,0 +1,270 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestLifecycleWatch(t *testing.T) {
+	for _, action := range []string{"stop", "purge"} {
+		t.Run(action, func(t *testing.T) {
+			root := t.TempDir()
+			pkg := filepath.Join(root, "package")
+			control := filepath.Join(pkg, "var", "executor", "control")
+			os.MkdirAll(filepath.Dir(control), 0700)
+			os.WriteFile(filepath.Join(pkg, "INFO"), []byte("package=\"TestApp\"\nversion=\"1\"\n"), 0600)
+			monitor := newLifecycleMonitor("TestApp", pkg, control, func(string) {})
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+			defer cancel()
+			result := make(chan string, 1)
+			go func() { result <- monitor.watch(ctx, time.Millisecond) }()
+			select {
+			case got := <-result:
+				t.Fatalf("stopped healthy package: %s", got)
+			case <-time.After(10 * time.Millisecond):
+			}
+			switch action {
+			default:
+				os.WriteFile(control, []byte(action+"\n"), 0600)
+			}
+			got := <-result
+			want := "purge"
+			if action == "stop" {
+				want = "stop"
+			}
+			if got != want || ctx.Err() != nil {
+				t.Fatalf("got %q, want %q (%v)", got, want, ctx.Err())
+			}
+			state := filepath.Join(root, "state")
+			socket := filepath.Join(root, "socket")
+			os.MkdirAll(filepath.Join(state, "runtime"), 0700)
+			os.MkdirAll(filepath.Join(state, "delegations"), 0700)
+			os.MkdirAll(socket, 0700)
+			if err := finishControl(state, filepath.Join(state, "runtime"), socket, got == "purge"); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := os.Stat(socket); !os.IsNotExist(err) {
+				t.Fatal("socket survived")
+			}
+			_, err := os.Stat(state)
+			if (got == "purge") != os.IsNotExist(err) {
+				t.Fatal("wrong protected state retention", err)
+			}
+		})
+	}
+}
+
+// Observe exactly one filesystem poll at an injected time. Cancellation ends a
+// poll that has no action, without sleeping or waiting ten real minutes.
+func observeLifecycle(t *testing.T, m *lifecycleMonitor, now time.Time) string {
+	t.Helper()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	m.now = func() time.Time { cancel(); return now }
+	return m.watch(ctx, time.Hour)
+}
+
+func TestMissingPackagePurgeRequiresTenContinuousMinutes(t *testing.T) {
+	for _, missing := range []string{"directory", "INFO", "identity", "mismatch", "duplicate"} {
+		t.Run(missing, func(t *testing.T) {
+			pkg := filepath.Join(t.TempDir(), "package")
+			if err := os.Mkdir(pkg, 0700); err != nil {
+				t.Fatal(err)
+			}
+			info := filepath.Join(pkg, "INFO")
+			content := "package=\"TestApp\"\n"
+			switch missing {
+			case "directory":
+				if err := os.Remove(pkg); err != nil {
+					t.Fatal(err)
+				}
+			case "identity":
+				content = "version=\"2\"\n"
+			case "mismatch":
+				content = "package=\"OtherApp\"\n"
+			case "duplicate":
+				content += content
+			}
+			if missing != "directory" && missing != "INFO" {
+				if err := os.WriteFile(info, []byte(content), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			m := newLifecycleMonitor("TestApp", pkg, filepath.Join(pkg, "control"), func(string) {})
+			start := time.Unix(1000, 0)
+			for _, elapsed := range []time.Duration{0, time.Minute, 10*time.Minute - time.Nanosecond} {
+				if got := observeLifecycle(t, m, start.Add(elapsed)); got != "stop" {
+					t.Fatalf("at %s: %q", elapsed, got)
+				}
+			}
+			if got := observeLifecycle(t, m, start.Add(10*time.Minute)); got != "purge" {
+				t.Fatalf("at cutoff: %q", got)
+			}
+		})
+	}
+}
+
+func TestMissingPackageTimerResetsWhenIdentityReturns(t *testing.T) {
+	pkg := t.TempDir()
+	info := filepath.Join(pkg, "INFO")
+	m := newLifecycleMonitor("TestApp", pkg, filepath.Join(pkg, "control"), func(string) {})
+	start := time.Unix(1000, 0)
+	if got := observeLifecycle(t, m, start); got != "stop" {
+		t.Fatal(got)
+	}
+	if err := os.WriteFile(info, []byte("package=\"TestApp\"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if got := observeLifecycle(t, m, start.Add(9*time.Minute)); got != "stop" {
+		t.Fatal(got)
+	}
+	if err := os.Remove(info); err != nil {
+		t.Fatal(err)
+	}
+	if got := observeLifecycle(t, m, start.Add(10*time.Minute)); got != "stop" {
+		t.Fatal("timer not reset", got)
+	}
+	if got := observeLifecycle(t, m, start.Add(19*time.Minute)); got != "stop" {
+		t.Fatal("purged too soon", got)
+	}
+	if got := observeLifecycle(t, m, start.Add(20*time.Minute)); got != "purge" {
+		t.Fatal("missing fallback purge", got)
+	}
+}
+
+func TestPurgeMailboxOverridesMissingPackageGracePeriod(t *testing.T) {
+	pkg := filepath.Join(t.TempDir(), "missing")
+	control := filepath.Join(t.TempDir(), "control")
+	if err := os.WriteFile(control, []byte("purge\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	m := newLifecycleMonitor("TestApp", pkg, control, func(string) {})
+	if got := observeLifecycle(t, m, time.Unix(1000, 0)); got != "purge" {
+		t.Fatal("purge mailbox delayed", got)
+	}
+}
+
+func TestMissingPackageRejectsStartAndUnreadableInfoResetsAbsence(t *testing.T) {
+	pkg := t.TempDir()
+	info := filepath.Join(pkg, "INFO")
+	control := filepath.Join(pkg, "control")
+	if err := os.WriteFile(control, []byte("start\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	m := newLifecycleMonitor("TestApp", pkg, control, func(string) {})
+	start := time.Unix(1000, 0)
+	if got := observeLifecycle(t, m, start); got != "stop" {
+		t.Fatal("start accepted without package identity", got)
+	}
+	// A symlink cannot be trusted as INFO, but does not prove it is absent.
+	if err := os.Symlink(control, info); err != nil {
+		t.Fatal(err)
+	}
+	if got := observeLifecycle(t, m, start.Add(9*time.Minute)); got != "stop" {
+		t.Fatal("unreadable identity resumed or purged", got)
+	}
+	if err := os.Remove(info); err != nil {
+		t.Fatal(err)
+	}
+	if got := observeLifecycle(t, m, start.Add(10*time.Minute)); got != "stop" {
+		t.Fatal("unverified absence counted toward purge", got)
+	}
+	if got := observeLifecycle(t, m, start.Add(20*time.Minute)); got != "purge" {
+		t.Fatal("confirmed absence did not purge", got)
+	}
+}
+
+func TestReappearedPackageHonorsStopCapturedBeforeApprovedBoot(t *testing.T) {
+	pkg := t.TempDir()
+	info := filepath.Join(pkg, "INFO")
+	control := filepath.Join(pkg, "control")
+	if err := os.WriteFile(control, []byte("stop\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	m := newLifecycleMonitor("TestApp", pkg, control, func(string) {})
+	start := time.Unix(1000, 0)
+	if got := observeLifecycle(t, m, start); got != "stop" {
+		t.Fatal(got)
+	}
+	if err := os.WriteFile(info, []byte("package=\"TestApp\"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	m.now = func() time.Time { return start.Add(time.Minute) }
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	if got := m.watch(ctx, time.Millisecond); got != "stop" || ctx.Err() != nil {
+		t.Fatal("old stop ignored after absence", got, ctx.Err())
+	}
+}
+func TestLifecycleWatchIgnoresInvalidControlAndResumesAfterOldStop(t *testing.T) {
+	root := t.TempDir()
+	pkg := filepath.Join(root, "package")
+	control := filepath.Join(pkg, "var", "executor", "control")
+	os.MkdirAll(filepath.Dir(control), 0700)
+	os.WriteFile(filepath.Join(pkg, "INFO"), []byte("package=\"TestApp\"\n"), 0600)
+	os.WriteFile(control, []byte("stop\n"), 0600)
+	var mu sync.Mutex
+	logs := 0
+	monitor := newLifecycleMonitor("TestApp", pkg, control, func(string) { mu.Lock(); logs++; mu.Unlock() })
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	result := make(chan string, 1)
+	go func() { result <- monitor.watch(ctx, time.Millisecond) }()
+	checkRunning := func() {
+		t.Helper()
+		select {
+		case got := <-result:
+			t.Fatalf("unexpected action %q", got)
+		case <-time.After(12 * time.Millisecond):
+		}
+	}
+	checkRunning()
+	for _, value := range []string{"STOP", " purge", "purge\n\n", "purge;id", "wrong"} {
+		os.WriteFile(control, []byte(value), 0600)
+		checkRunning()
+	}
+	mu.Lock()
+	count := logs
+	mu.Unlock()
+	if count < 5 {
+		t.Fatalf("missing invalid-control logs: %d", count)
+	}
+	// Atomic replacement is a fresh request, even when its contents match old stop.
+	next := control + ".new"
+	os.WriteFile(next, []byte("stop\n"), 0600)
+	os.Rename(next, control)
+	if got := <-result; got != "stop" || ctx.Err() != nil {
+		t.Fatal(got, ctx.Err())
+	}
+}
+func TestLifecycleWatchHonorsPendingPurgeAtStartup(t *testing.T) {
+	root := t.TempDir()
+	os.WriteFile(filepath.Join(root, "INFO"), []byte("package=\"TestApp\"\n"), 0600)
+	control := filepath.Join(root, "control")
+	os.WriteFile(control, []byte("purge\n"), 0600)
+	monitor := newLifecycleMonitor("TestApp", root, control, func(string) {})
+	if got := monitor.watch(context.Background(), time.Millisecond); got != "purge" {
+		t.Fatal(got)
+	}
+}
+
+func TestLifecycleMonitorReadsStartAfterStopAndKeepsCheckingPurge(t *testing.T) {
+	dir := realTestPath(t, t.TempDir())
+	os.WriteFile(filepath.Join(dir, "INFO"), []byte("package=\"TestApp\"\n"), 0600)
+	control := filepath.Join(dir, "control")
+	monitor := newLifecycleMonitor("TestApp", dir, control, func(string) {})
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	for _, action := range []string{"stop", "start", "stop", "purge"} {
+		tmp := control + ".new"
+		os.WriteFile(tmp, []byte(action+"\n"), 0600)
+		os.Rename(tmp, control)
+		if got := monitor.watch(ctx, time.Millisecond); got != action || ctx.Err() != nil {
+			t.Fatal(got, action, ctx.Err())
+		}
+	}
+}

package/dist/templates/_executor/write_review_linux_test.go

@@ -0,0 +1,95 @@
+//go:build linux
+
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestReviewCopyChild(t *testing.T) {
+	if os.Getenv("P2_REVIEW_COPY_CHILD") != "1" {
+		t.Skip("child only")
+	}
+	if err := runWriteChild(os.Getenv("P2_REVIEW_CLEANUP_CHILD") == "1"); err != nil {
+		os.Exit(2)
+	}
+	os.Exit(0)
+}
+func TestReviewCanceledWriteDoesNotLeavePartialDestination(t *testing.T) {
+	if os.Geteuid() != 0 {
+		t.Skip("requires disposable local Linux root runner")
+	}
+	base, err := os.MkdirTemp("/tmp", "p2review-write-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(base)
+	os.Chmod(base, 0711)
+	stage, dest := filepath.Join(base, "stage"), filepath.Join(base, "dest")
+	os.Mkdir(stage, 0700)
+	os.Mkdir(dest, 0700)
+	s := Subject{UID: 1200, GID: 100, Groups: []int{100}}
+	os.Chown(dest, s.UID, s.GID)
+	src, err := os.Create(filepath.Join(stage, "source"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = src.Truncate(1 << 40); err != nil {
+		src.Close()
+		t.Skip(err)
+	}
+	src.Close()
+	binary, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	launcher := filepath.Join(base, "child")
+	body := "#!/bin/sh\nexport P2_REVIEW_COPY_CHILD=1\n[ \"$1\" != cleanup-child ] || export P2_REVIEW_CLEANUP_CHILD=1\nexec " + strconv.Quote(binary) + " -test.run=^TestReviewCopyChild$\n"
+	os.WriteFile(launcher, []byte(body), 0700)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	done := make(chan error, 1)
+	w := subprocessWriter{Staging: stage, Executable: launcher, PackageUID: 0}
+	go func() {
+		done <- w.Write(context.WithValue(ctx, writeJobKey{}, "job1"), s, "source", dest, "file", dest)
+	}()
+	target := filepath.Join(dest, "file")
+	deadline := time.After(3 * time.Second)
+	for {
+		entries, _ := os.ReadDir(dest)
+		writing := false
+		for _, entry := range entries {
+			info, _ := entry.Info()
+			if info != nil && info.Size() > 0 {
+				writing = true
+			}
+		}
+		if writing {
+			break
+		}
+		select {
+		case err := <-done:
+			t.Fatalf("child ended before write: %v", err)
+		case <-deadline:
+			t.Fatal("write did not start")
+		default:
+			time.Sleep(time.Millisecond)
+		}
+	}
+	cancel()
+	if err := <-done; err == nil {
+		t.Fatal("expected cancellation")
+	}
+	entries, _ := os.ReadDir(dest)
+	if len(entries) != 0 {
+		t.Fatal("temporary file survived cancellation", entries)
+	}
+	if _, err = os.Stat(target); !os.IsNotExist(err) {
+		t.Fatal("WRITE_FAILED left a partial destination")
+	}
+}

package/dist/templates/_shared/AGENTS.md

@@ -0,0 +1,17 @@
+# AI authoring
+
+Start with `synopkgland skill list`, then `synopkgland skill show orchestrator`.
+Use `synopkgland skill path` to locate the bundled references; read the relevant
+skill with `synopkgland skill show <id>` before editing.
+For UI work, read `synopkgland skill show ui-vue` and `synopkgland skill show ui-json`.
+Use the installed SDK contracts and preserve package.json/lockfile pins.
+
+For UI discovery, run `npx --no syno-pkg-land-ui catalog --json` and
+`npx --no syno-pkg-land-ui describe Button --json` from the installed frontend.
+Read its prompt and exported Vue docs/types before choosing component APIs.
+Use `syno-pkg-land-ui` directly in npm scripts; keep AI guidance version-independent.
+
+From the project root, run `synopkgland check --json`,
+`synopkgland build --json`, then `synopkgland inspect <spk> --json` on the emitted SPK.
+For Vue, first run `npm ci`, `npm test` and `npm run build` in frontend.
+Do not connect to or change a NAS without explicit task authorization.

package/dist/templates/_shared/CLAUDE.md

@@ -0,0 +1 @@
+Read [AGENTS.md](AGENTS.md).

package/dist/templates/binary/LICENSES/GO-LICENSE

@@ -0,0 +1,27 @@
+Copyright 2009 The Go Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/templates/binary/LICENSES/GO-PATENTS

@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.

package/dist/templates/binary/dsm-package.yaml

@@ -0,0 +1,19 @@
+# A prebuilt, static Linux CGI using the same DSM package surface as native-go.
+schema: 2
+package: __PACKAGE__
+version: 0.1.0
+build: 1
+displayname: __DISPLAY_NAME__
+description: A DSM package with a prebuilt binary CGI and DSM window UI.
+maintainer: Your Name
+os_min_ver: "7.1-42661"
+arches: [x86_64, aarch64]
+backend:
+  kind: binary
+  files:
+    x86_64: prebuilt/api-x86_64
+    aarch64: prebuilt/api-aarch64
+ui: {dir: ui}
+# init compiles example/main.go for convenience. Replace prebuilt/api-* with
+# your application's static Linux ELF files; the CGI owns authentication.
+# daemon may optionally declare a separately packaged foreground service.

package/dist/templates/binary/example/main.go

@@ -0,0 +1,16 @@
+// The starter CGI is compiled once by init. Production binary apps supply their
+// own static Linux executables and must authenticate their application routes.
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/cgi"
+)
+
+func main() {
+	_ = cgi.Serve(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		_ = json.NewEncoder(w).Encode(map[string]string{"status": "ready", "backend": "binary"})
+	}))
+}

package/dist/templates/binary/gitignore

@@ -0,0 +1,2 @@
+dist/
+*.spk

package/dist/templates/binary/ui/app.css

@@ -0,0 +1,4 @@
+:root { font-family: system-ui, sans-serif; color: #1e293b; background: #f8fafc; }
+.binary-app { padding: 2rem; }
+.binary-app h1 { font-size: 1.5rem; }
+.binary-app p { line-height: 1.6; }

package/dist/templates/binary/ui/app.js

@@ -0,0 +1,17 @@
+(function () {
+  "use strict";
+  window.DsmPackageApps = window.DsmPackageApps || {};
+  window.DsmPackageApps["__PACKAGE__"] = {
+    mount(root) {
+      const app = document.createElement("main");
+      app.className = "binary-app";
+      const title = document.createElement("h1");
+      title.textContent = "Binary App";
+      const description = document.createElement("p");
+      description.textContent = "Your prebuilt CGI is packaged in this DSM application.";
+      app.append(title, description);
+      root.append(app);
+      return { unmount() { app.remove(); } };
+    },
+  };
+})();