@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/windows-launcher/LauncherVerificationBehaviorTests.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+
+namespace ZaipDashboardLauncher
+{
+    internal static class LauncherVerificationBehaviorTests
+    {
+        private static int Main()
+        {
+            try
+            {
+                AcceptsSessionAndHealthThatBecomeReadyWithinTheWindow();
+                AcceptsCompletedHandoffWhenTheMutableSessionHasDisappeared();
+                RejectsMismatchedWorkspaceIdentity();
+                FailsWhenTheSessionNeverBecomesAvailable();
+                Console.WriteLine("Launcher verification behavior tests passed.");
+                return 0;
+            }
+            catch (Exception exception)
+            {
+                Console.Error.WriteLine(exception);
+                return 1;
+            }
+        }
+
+        private static void AcceptsSessionAndHealthThatBecomeReadyWithinTheWindow()
+        {
+            var workspaceRoot = NewWorkspaceRoot();
+            var expectedKey = WorkspaceKey(workspaceRoot);
+            using (var server = new HealthServer(expectedKey))
+            {
+                RemoveSession(workspaceRoot);
+                var writer = new Thread(delegate()
+                {
+                    Thread.Sleep(350);
+                    WriteSession(workspaceRoot, server.Port);
+                });
+                writer.Start();
+                string error;
+                var result = Verify(workspaceRoot, out error);
+                writer.Join();
+
+                Require(result, "Expected delayed session and matching health to be accepted: " + error);
+                RemoveSession(workspaceRoot);
+            }
+        }
+
+        private static void RejectsMismatchedWorkspaceIdentity()
+        {
+            var workspaceRoot = NewWorkspaceRoot();
+            using (var server = new HealthServer("other-workspace"))
+            {
+                WriteSession(workspaceRoot, server.Port);
+                var elapsed = Stopwatch.StartNew();
+                string error;
+                var result = Verify(workspaceRoot, out error);
+                elapsed.Stop();
+
+                Require(!result, "Expected mismatched workspace identity to be rejected.");
+                Require(elapsed.ElapsedMilliseconds >= 4500, "Expected mismatched identity polling to wait through the bounded window.");
+                RemoveSession(workspaceRoot);
+            }
+        }
+
+        private static void AcceptsCompletedHandoffWhenTheMutableSessionHasDisappeared()
+        {
+            var statusPath = Path.Combine(Path.GetTempPath(), "zaip-dashboard-launcher-status-" + Guid.NewGuid().ToString("N"));
+            try
+            {
+                // Node already observed health/readiness and atomically published `ok`.
+                // A later session-registry lookup must not turn that handoff into an error.
+                File.WriteAllText(statusPath, "ok");
+                var result = WaitForLaunchStatus(Process.GetCurrentProcess(), statusPath, "workspace-without-a-session");
+                Require(result == 0, "Expected an already confirmed handoff to succeed without rediscovering the session.");
+            }
+            finally
+            {
+                if (File.Exists(statusPath)) File.Delete(statusPath);
+            }
+        }
+
+        private static void FailsWhenTheSessionNeverBecomesAvailable()
+        {
+            var workspaceRoot = NewWorkspaceRoot();
+            RemoveSession(workspaceRoot);
+            var elapsed = Stopwatch.StartNew();
+            string error;
+            var result = Verify(workspaceRoot, out error);
+            elapsed.Stop();
+
+            Require(!result, "Expected permanently unavailable session to fail.");
+            Require(elapsed.ElapsedMilliseconds >= 4500, "Expected unavailable session polling to wait through the bounded window.");
+            Require(error != null && error.IndexOf("5 segundos", StringComparison.Ordinal) >= 0, "Expected the bounded timeout error.");
+        }
+
+        private static bool Verify(string workspaceRoot, out string error)
+        {
+            var method = typeof(Program).GetMethod("VerifyDashboardLaunch", BindingFlags.NonPublic | BindingFlags.Static);
+            var arguments = new object[] { workspaceRoot, null };
+            var result = (bool)method.Invoke(null, arguments);
+            error = (string)arguments[1];
+            return result;
+        }
+
+        private static int WaitForLaunchStatus(Process process, string statusPath, string workspaceRoot)
+        {
+            var method = typeof(Program).GetMethod("WaitForLaunchStatus", BindingFlags.NonPublic | BindingFlags.Static);
+            return (int)method.Invoke(null, new object[] { process, statusPath, workspaceRoot });
+        }
+
+        private static string NewWorkspaceRoot()
+        {
+            return "launcher-behavior-" + Guid.NewGuid().ToString("N");
+        }
+
+        private static string WorkspaceKey(string workspaceRoot)
+        {
+            using (var sha256 = SHA256.Create())
+            {
+                var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(workspaceRoot + ":dashboard-sqlite"));
+                var result = new StringBuilder(16);
+                for (var index = 0; index < 8; index++) result.Append(hash[index].ToString("x2"));
+                return result.ToString();
+            }
+        }
+
+        private static string SessionPath(string workspaceRoot)
+        {
+            return Path.Combine(Path.GetTempPath(), "zaip-aios", "dashboard-sqlite-" + WorkspaceKey(workspaceRoot), "dashboard-sqlite-session.json");
+        }
+
+        private static void WriteSession(string workspaceRoot, int port)
+        {
+            var path = SessionPath(workspaceRoot);
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+            File.WriteAllText(path, "{\"port\":" + port + "}");
+        }
+
+        private static void RemoveSession(string workspaceRoot)
+        {
+            var path = SessionPath(workspaceRoot);
+            if (File.Exists(path)) File.Delete(path);
+        }
+
+        private static void Require(bool condition, string message)
+        {
+            if (!condition) throw new InvalidOperationException(message);
+        }
+
+        private sealed class HealthServer : IDisposable
+        {
+            private readonly TcpListener listener;
+            private readonly string workspaceKey;
+            private readonly Thread worker;
+            private volatile bool disposed;
+
+            public HealthServer(string workspaceKey)
+            {
+                this.workspaceKey = workspaceKey;
+                listener = new TcpListener(System.Net.IPAddress.Loopback, 0);
+                listener.Start();
+                Port = ((IPEndPoint)listener.LocalEndpoint).Port;
+                worker = new Thread(Listen);
+                worker.IsBackground = true;
+                worker.Start();
+            }
+
+            public int Port { get; private set; }
+
+            public void Dispose()
+            {
+                disposed = true;
+                listener.Stop();
+                worker.Join(1000);
+            }
+
+            private void Listen()
+            {
+                while (!disposed)
+                {
+                    try
+                    {
+                        using (var client = listener.AcceptTcpClient())
+                        using (var stream = client.GetStream())
+                        {
+                            var payload = "{\"kind\":\"zaip-dashboard-sqlite-runtime\",\"workspaceKey\":\"" + workspaceKey + "\"}";
+                            var bytes = Encoding.UTF8.GetBytes("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: " + Encoding.UTF8.GetByteCount(payload) + "\r\nConnection: close\r\n\r\n" + payload);
+                            stream.Write(bytes, 0, bytes.Length);
+                        }
+                    }
+                    catch (SocketException)
+                    {
+                        if (!disposed) throw;
+                    }
+                }
+            }
+        }
+    }
+}

package/templates/.agents/dashboard/packages/windows-launcher/Program.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.Net;
 using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 
@@ -10,6 +13,8 @@ namespace ZaipDashboardLauncher
     internal static class Program
     {
         private const int ErrorIcon = 0x00000010;
+        private const int LaunchVerificationTimeoutMilliseconds = 5000;
+        private const int LaunchVerificationRetryMilliseconds = 200;
 
         [DllImport("user32.dll", CharSet = CharSet.Unicode)]
         private static extern int MessageBox(IntPtr handle, string text, string caption, int type);
@@ -40,7 +45,7 @@ namespace ZaipDashboardLauncher
 
                 statusPath = Path.Combine(
                     Path.GetTempPath(),
-                    string.Format("zaip-dashboard-launch-{0}.status", Guid.NewGuid().ToString("N"))
+                    string.Format("zaip-dashboard-sqlite-launch-{0}.status", Guid.NewGuid().ToString("N"))
                 );
                 var startInfo = new ProcessStartInfo(nodePath, string.Format("\"{0}\"", scriptPath))
                 {
@@ -57,7 +62,7 @@ namespace ZaipDashboardLauncher
                     return ReportFailure("Não foi possível iniciar o processo do dashboard.");
                 }
 
-                return WaitForLaunchStatus(process, statusPath);
+                return WaitForLaunchStatus(process, statusPath, workspaceRoot);
             }
             catch (Exception exception)
             {
@@ -72,7 +77,7 @@ namespace ZaipDashboardLauncher
             }
         }
 
-        private static int WaitForLaunchStatus(Process process, string statusPath)
+        private static int WaitForLaunchStatus(Process process, string statusPath, string workspaceRoot)
         {
             // The Node launcher coalesces concurrent clicks and may wait for a
             // healthy build/handoff.  Keep this wrapper alive for that bounded
@@ -85,13 +90,22 @@ namespace ZaipDashboardLauncher
                     if (File.Exists(statusPath))
                     {
                         var status = File.ReadAllText(statusPath);
-                        if (status.StartsWith("ok", StringComparison.OrdinalIgnoreCase)) return 0;
+                        if (status.StartsWith("ok", StringComparison.OrdinalIgnoreCase))
+                        {
+                            // Node publishes `ok` only after confirming the selected
+                            // runtime's health/readiness and handing off the browser.
+                            // Re-reading the mutable session registry here can race a
+                            // later launch or cleanup and show a false native popup.
+                            return 0;
+                        }
                         if (status.StartsWith("warning", StringComparison.OrdinalIgnoreCase))
                         {
                             var warning = StatusMessage(status);
                             LogFailure(warning);
-                            MessageBox(IntPtr.Zero, warning, "ZAIP Dashboard", 0x00000030);
-                            return 0;
+                            string verificationError;
+                            return VerifyDashboardLaunch(workspaceRoot, out verificationError)
+                                ? 0
+                                : ReportFailure(verificationError);
                         }
                         return ReportFailure(StatusMessage(status));
                     }
@@ -111,6 +125,79 @@ namespace ZaipDashboardLauncher
             return ReportFailure("O dashboard demorou mais de 135 segundos para abrir. As tentativas foram interrompidas; tente novamente.");
         }
 
+        private static bool VerifyDashboardLaunch(string workspaceRoot, out string error)
+        {
+            error = null;
+            var workspaceKey = DashboardWorkspaceKey(workspaceRoot);
+            var sessionDirectory = Path.Combine(Path.GetTempPath(), "zaip-aios", "dashboard-sqlite-" + workspaceKey);
+            var sessionPath = Path.Combine(sessionDirectory, "dashboard-sqlite-session.json");
+            var deadline = DateTime.UtcNow.AddMilliseconds(LaunchVerificationTimeoutMilliseconds);
+            while (DateTime.UtcNow < deadline)
+            {
+                var currentPort = ReadJsonInteger(sessionPath, "port");
+                if (currentPort.HasValue && IsOwnedDashboardHealthy(currentPort.Value, workspaceKey))
+                {
+                    // The new same-workspace healthy port is definitive success.
+                    // Previous-port cleanup remains best-effort and auditable in Node.
+                    return true;
+                }
+
+                Thread.Sleep(LaunchVerificationRetryMilliseconds);
+            }
+
+            error = "O launcher recebeu sucesso, mas não confirmou o carregamento do novo dashboard em 5 segundos.";
+            return false;
+        }
+
+        private static int? ReadJsonInteger(string path, string property)
+        {
+            try
+            {
+                if (!File.Exists(path)) return null;
+                var match = Regex.Match(File.ReadAllText(path), "\\\"" + Regex.Escape(property) + "\\\"\\s*:\\s*(\\d+)");
+                int value;
+                return match.Success && int.TryParse(match.Groups[1].Value, out value) ? value : (int?)null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static bool IsOwnedDashboardHealthy(int port, string workspaceKey)
+        {
+            try
+            {
+                var request = (HttpWebRequest)WebRequest.Create(string.Format("http://127.0.0.1:{0}/api/v2/health", port));
+                request.Method = "GET";
+                request.Timeout = 1000;
+                request.ReadWriteTimeout = 1000;
+                using (var response = (HttpWebResponse)request.GetResponse())
+                using (var reader = new StreamReader(response.GetResponseStream()))
+                {
+                    var payload = reader.ReadToEnd();
+                    return response.StatusCode == HttpStatusCode.OK
+                        && Regex.IsMatch(payload, "\\\"kind\\\"\\s*:\\s*\\\"zaip-dashboard-sqlite-runtime\\\"")
+                        && Regex.IsMatch(payload, "\\\"workspaceKey\\\"\\s*:\\s*\\\"" + Regex.Escape(workspaceKey) + "\\\"");
+                }
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private static string DashboardWorkspaceKey(string workspaceRoot)
+        {
+            using (var sha256 = SHA256.Create())
+            {
+                var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(workspaceRoot + ":dashboard-sqlite"));
+                var builder = new StringBuilder(16);
+                for (var index = 0; index < 8; index++) builder.Append(hash[index].ToString("x2"));
+                return builder.ToString();
+            }
+        }
+
         private static string StatusMessage(string status)
         {
             var separator = status.IndexOf('\n');
@@ -130,7 +217,7 @@ namespace ZaipDashboardLauncher
             var sanitized = Regex.Replace(message, "\\x1B\\[[0-?]*[ -/]*[@-~]", string.Empty)
                 .Replace("\r", string.Empty)
                 .Trim();
-            const int maximumLength = 3600;
+            const int maximumLength = 900;
             if (sanitized.Length <= maximumLength) return sanitized;
 
             const int firstHalf = maximumLength / 2;
@@ -155,7 +242,7 @@ namespace ZaipDashboardLauncher
             try
             {
                 var tempPath = Path.GetTempPath();
-                var logPath = Path.Combine(tempPath, "zaip-dashboard-launcher.log");
+                var logPath = Path.Combine(tempPath, "zaip-dashboard-sqlite-launcher.log");
                 File.AppendAllText(logPath, string.Format("[{0}] {1}{2}", DateTime.UtcNow.ToString("O"), message, Environment.NewLine));
             }
             catch

package/templates/.agents/dashboard/packages/windows-launcher/build-dashboard-launcher.ps1

@@ -1,5 +1,5 @@
 param(
-  [string]$OutputPath = ".agents/dashboard/zaip-dashboard.exe",
+  [string]$OutputPath = ".agents/dashboard/zaip-dashboard-windows.exe",
   [string]$IconPath = ".agents/config/src/icon_zaip.png",
   [switch]$SkipReleaseSync
 )
@@ -9,7 +9,7 @@ $ErrorActionPreference = "Stop"
 $repoRoot = (Resolve-Path (Join-Path $PSScriptRoot "../../../..")).Path
 $sourcePath = Join-Path $PSScriptRoot "Program.cs"
 $targetPath = Join-Path $repoRoot $OutputPath
-$canonicalTargetPath = Join-Path $repoRoot ".agents/dashboard/zaip-dashboard.exe"
+$canonicalTargetPath = Join-Path $repoRoot ".agents/dashboard/zaip-dashboard-windows.exe"
 $resolvedIconPath = if ([System.IO.Path]::IsPathRooted($IconPath)) { $IconPath } else { Join-Path $repoRoot $IconPath }
 
 function Get-PngDimension {

package/templates/.agents/dashboard/packages/windows-launcher/run-launcher-verification-tests.ps1

@@ -0,0 +1,22 @@
+$ErrorActionPreference = "Stop"
+
+$compiler = @(
+  "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe",
+  "C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe"
+) | Where-Object { Test-Path $_ } | Select-Object -First 1
+
+if (-not $compiler) {
+  throw "Nenhum compilador C# local encontrado para executar os testes comportamentais do launcher."
+}
+
+$outputPath = Join-Path ([System.IO.Path]::GetTempPath()) ("zaip-dashboard-launcher-tests-" + [Guid]::NewGuid().ToString("N") + ".exe")
+try {
+  & $compiler /nologo /target:exe /main:ZaipDashboardLauncher.LauncherVerificationBehaviorTests /out:$outputPath (Join-Path $PSScriptRoot "Program.cs") (Join-Path $PSScriptRoot "LauncherVerificationBehaviorTests.cs")
+  if ($LASTEXITCODE -ne 0) { throw "Falha ao compilar os testes comportamentais do launcher." }
+
+  & $outputPath
+  if ($LASTEXITCODE -ne 0) { throw "Falha nos testes comportamentais do launcher." }
+}
+finally {
+  if (Test-Path $outputPath) { Remove-Item -LiteralPath $outputPath -Force }
+}