looply-cli 0.5.4 → 0.5.5

package/package.json

@@ -1,54 +1,54 @@
-{
-  "name": "looply-cli",
-  "version": "0.5.4",
-  "description": "Leave your coding agent running. looply picks the work, holds the rails, and proves every change before it is kept.",
-  "license": "MIT",
-  "bin": {
-    "looply": "dist/bin.js"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "win",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "claude",
-    "claude-code",
-    "coding-agent",
-    "agent",
-    "autonomous",
-    "loop",
-    "ci",
-    "codegen",
-    "automation"
-  ],
-  "scripts": {
-    "build": "tsc -b",
-    "clean": "tsc -b --clean",
-    "prepack": "npm run build",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@looply/core": "0.5.4",
-    "pdfjs-dist": "5.6.205",
-    "qrcode-terminal": "^0.12.0",
-    "yaml": "^2.5.1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/georgeemichel/looply.git"
-  },
-  "homepage": "https://looply-agent-app.web.app",
-  "bugs": {
-    "url": "https://github.com/georgeemichel/looply/issues"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "looply-cli",
+  "version": "0.5.5",
+  "description": "Leave your coding agent running. looply picks the work, holds the rails, and proves every change before it is kept.",
+  "license": "MIT",
+  "bin": {
+    "looply": "dist/bin.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "win",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "coding-agent",
+    "agent",
+    "autonomous",
+    "loop",
+    "ci",
+    "codegen",
+    "automation"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@looply/core": "0.5.5",
+    "pdfjs-dist": "5.6.205",
+    "qrcode-terminal": "^0.12.0",
+    "yaml": "^2.5.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/georgeemichel/looply.git"
+  },
+  "homepage": "https://looply-agent-app.web.app",
+  "bugs": {
+    "url": "https://github.com/georgeemichel/looply/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/win/HandleProbe.cs

@@ -1,116 +1,116 @@
-using System;
-using System.Runtime.InteropServices;
-
-/*
- * WHAT DID THIS PROCESS INHERIT THAT NOBODY MEANT TO GIVE IT?
- *
- * Compiled from source at test time, never checked in as a binary — the same
- * rule CredProbe.cs and TokenProbe.cs follow.
- *
- * The launcher opens three FILE handles for the contained child's stdio and
- * passes them deliberately. Anything else inheritable in the launching process
- * used to ride along, because CreateProcess was called with bInheritHandles =
- * true and an attribute list naming only SECURITY_CAPABILITIES. The launching
- * process is powershell.exe, spawned by Node with three PIPE handles — so the
- * question is not "how many handles do I hold" but "do I hold any PIPE
- * handles", since the three intended ones are all FILE_TYPE_DISK.
- *
- * 🔴 IT DOES NOT GUESS HANDLE VALUES. Walking 4, 8, 12… and calling GetFileType
- * kills the process outright inside an AppContainer: strict handle checking
- * turns the first invalid reference into STATUS_INVALID_HANDLE (0xC0000008) and
- * the container reports a launch that never produced output. Measured, not
- * assumed — the count-only mode below runs fine while the scan died.
- *
- * So the handle table is asked for ITS OWN CONTENTS, via
- * NtQueryInformationProcess(ProcessHandleInformation). Every value that comes
- * back is real, so GetFileType is safe on all of them, and the table also
- * carries HandleAttributes — OBJ_INHERIT tells us which ones would be passed on
- * again.
- *
- * ⚠️ AND IT WRITES TO NOTHING. Proving a handle is there does not require
- * crossing the boundary, and writing to an inherited pipe would corrupt the
- * very channel the launcher parses its reply from.
- */
-static class HandleProbe {
-  [DllImport("kernel32.dll", SetLastError = true)]
-  static extern uint GetFileType(IntPtr hFile);
-  [DllImport("kernel32.dll", SetLastError = true)]
-  static extern bool GetProcessHandleCount(IntPtr hProcess, out uint pdwHandleCount);
-  [DllImport("kernel32.dll")]
-  static extern IntPtr GetCurrentProcess();
-  [DllImport("ntdll.dll")]
-  static extern int NtQueryInformationProcess(IntPtr h, int cls, IntPtr info, int len, out int ret);
-
-  const uint FILE_TYPE_DISK = 0x0001;
-  const uint FILE_TYPE_CHAR = 0x0002;
-  const uint FILE_TYPE_PIPE = 0x0003;
-
-  /** ProcessHandleInformation — the process's own handle table, Win8.1+. */
-  const int ProcessHandleInformation = 51;
-  const uint OBJ_INHERIT = 0x00000002;
-
-  [StructLayout(LayoutKind.Sequential)]
-  struct PROCESS_HANDLE_TABLE_ENTRY_INFO {
-    public IntPtr HandleValue;
-    public IntPtr HandleCount;
-    public IntPtr PointerCount;
-    public uint GrantedAccess;
-    public uint ObjectTypeIndex;
-    public uint HandleAttributes;
-    public uint Reserved;
-  }
-
-  static int Main(string[] args) {
-    uint total = 0;
-    GetProcessHandleCount(GetCurrentProcess(), out total);
-    if (args.Length > 0 && args[0] == "count") {
-      Console.WriteLine("LOOPLY-COUNT total=" + total);
-      return 0;
-    }
-
-    int pipes = 0, disks = 0, chars = 0, inheritablePipes = 0, listed = 0;
-
-    // Grow until it fits: the table can change size between the sizing call and
-    // the real one, so this asks with a generous buffer and retries.
-    int len = 64 * 1024;
-    for (int attempt = 0; attempt < 4; attempt++) {
-      IntPtr buf = Marshal.AllocHGlobal(len);
-      try {
-        int needed;
-        int status = NtQueryInformationProcess(GetCurrentProcess(), ProcessHandleInformation, buf, len, out needed);
-        if (status != 0) {
-          if (needed > len) { len = needed + 8192; continue; }
-          Console.WriteLine("LOOPLY-HANDLES unavailable status=0x" + status.ToString("X8") + " total=" + total);
-          return 0;
-        }
-        // PROCESS_HANDLE_SNAPSHOT_INFORMATION: NumberOfHandles, Reserved, then
-        // the entries.
-        IntPtr count = Marshal.ReadIntPtr(buf, 0);
-        int n = (int)count.ToInt64();
-        int header = IntPtr.Size * 2;
-        int stride = Marshal.SizeOf(typeof(PROCESS_HANDLE_TABLE_ENTRY_INFO));
-        for (int i = 0; i < n; i++) {
-          IntPtr at = new IntPtr(buf.ToInt64() + header + ((long)i * stride));
-          PROCESS_HANDLE_TABLE_ENTRY_INFO e =
-            (PROCESS_HANDLE_TABLE_ENTRY_INFO)Marshal.PtrToStructure(at, typeof(PROCESS_HANDLE_TABLE_ENTRY_INFO));
-          listed++;
-          uint t = GetFileType(e.HandleValue);
-          if (t == FILE_TYPE_PIPE) {
-            pipes++;
-            if ((e.HandleAttributes & OBJ_INHERIT) != 0) inheritablePipes++;
-          } else if (t == FILE_TYPE_DISK) disks++;
-          else if (t == FILE_TYPE_CHAR) chars++;
-        }
-        break;
-      } finally {
-        Marshal.FreeHGlobal(buf);
-      }
-    }
-
-    // One line, parsed by the test. stdout here is one of the intended handles,
-    // so this line arriving at all is itself part of the evidence.
-    Console.WriteLine("LOOPLY-HANDLES pipes=" + pipes + " disks=" + disks + " chars=" + chars
-      + " inheritablePipes=" + inheritablePipes + " listed=" + listed + " total=" + total);
-    return 0;
-  }
-}
+using System;
+using System.Runtime.InteropServices;
+
+/*
+ * WHAT DID THIS PROCESS INHERIT THAT NOBODY MEANT TO GIVE IT?
+ *
+ * Compiled from source at test time, never checked in as a binary — the same
+ * rule CredProbe.cs and TokenProbe.cs follow.
+ *
+ * The launcher opens three FILE handles for the contained child's stdio and
+ * passes them deliberately. Anything else inheritable in the launching process
+ * used to ride along, because CreateProcess was called with bInheritHandles =
+ * true and an attribute list naming only SECURITY_CAPABILITIES. The launching
+ * process is powershell.exe, spawned by Node with three PIPE handles — so the
+ * question is not "how many handles do I hold" but "do I hold any PIPE
+ * handles", since the three intended ones are all FILE_TYPE_DISK.
+ *
+ * 🔴 IT DOES NOT GUESS HANDLE VALUES. Walking 4, 8, 12… and calling GetFileType
+ * kills the process outright inside an AppContainer: strict handle checking
+ * turns the first invalid reference into STATUS_INVALID_HANDLE (0xC0000008) and
+ * the container reports a launch that never produced output. Measured, not
+ * assumed — the count-only mode below runs fine while the scan died.
+ *
+ * So the handle table is asked for ITS OWN CONTENTS, via
+ * NtQueryInformationProcess(ProcessHandleInformation). Every value that comes
+ * back is real, so GetFileType is safe on all of them, and the table also
+ * carries HandleAttributes — OBJ_INHERIT tells us which ones would be passed on
+ * again.
+ *
+ * ⚠️ AND IT WRITES TO NOTHING. Proving a handle is there does not require
+ * crossing the boundary, and writing to an inherited pipe would corrupt the
+ * very channel the launcher parses its reply from.
+ */
+static class HandleProbe {
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern uint GetFileType(IntPtr hFile);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool GetProcessHandleCount(IntPtr hProcess, out uint pdwHandleCount);
+  [DllImport("kernel32.dll")]
+  static extern IntPtr GetCurrentProcess();
+  [DllImport("ntdll.dll")]
+  static extern int NtQueryInformationProcess(IntPtr h, int cls, IntPtr info, int len, out int ret);
+
+  const uint FILE_TYPE_DISK = 0x0001;
+  const uint FILE_TYPE_CHAR = 0x0002;
+  const uint FILE_TYPE_PIPE = 0x0003;
+
+  /** ProcessHandleInformation — the process's own handle table, Win8.1+. */
+  const int ProcessHandleInformation = 51;
+  const uint OBJ_INHERIT = 0x00000002;
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct PROCESS_HANDLE_TABLE_ENTRY_INFO {
+    public IntPtr HandleValue;
+    public IntPtr HandleCount;
+    public IntPtr PointerCount;
+    public uint GrantedAccess;
+    public uint ObjectTypeIndex;
+    public uint HandleAttributes;
+    public uint Reserved;
+  }
+
+  static int Main(string[] args) {
+    uint total = 0;
+    GetProcessHandleCount(GetCurrentProcess(), out total);
+    if (args.Length > 0 && args[0] == "count") {
+      Console.WriteLine("LOOPLY-COUNT total=" + total);
+      return 0;
+    }
+
+    int pipes = 0, disks = 0, chars = 0, inheritablePipes = 0, listed = 0;
+
+    // Grow until it fits: the table can change size between the sizing call and
+    // the real one, so this asks with a generous buffer and retries.
+    int len = 64 * 1024;
+    for (int attempt = 0; attempt < 4; attempt++) {
+      IntPtr buf = Marshal.AllocHGlobal(len);
+      try {
+        int needed;
+        int status = NtQueryInformationProcess(GetCurrentProcess(), ProcessHandleInformation, buf, len, out needed);
+        if (status != 0) {
+          if (needed > len) { len = needed + 8192; continue; }
+          Console.WriteLine("LOOPLY-HANDLES unavailable status=0x" + status.ToString("X8") + " total=" + total);
+          return 0;
+        }
+        // PROCESS_HANDLE_SNAPSHOT_INFORMATION: NumberOfHandles, Reserved, then
+        // the entries.
+        IntPtr count = Marshal.ReadIntPtr(buf, 0);
+        int n = (int)count.ToInt64();
+        int header = IntPtr.Size * 2;
+        int stride = Marshal.SizeOf(typeof(PROCESS_HANDLE_TABLE_ENTRY_INFO));
+        for (int i = 0; i < n; i++) {
+          IntPtr at = new IntPtr(buf.ToInt64() + header + ((long)i * stride));
+          PROCESS_HANDLE_TABLE_ENTRY_INFO e =
+            (PROCESS_HANDLE_TABLE_ENTRY_INFO)Marshal.PtrToStructure(at, typeof(PROCESS_HANDLE_TABLE_ENTRY_INFO));
+          listed++;
+          uint t = GetFileType(e.HandleValue);
+          if (t == FILE_TYPE_PIPE) {
+            pipes++;
+            if ((e.HandleAttributes & OBJ_INHERIT) != 0) inheritablePipes++;
+          } else if (t == FILE_TYPE_DISK) disks++;
+          else if (t == FILE_TYPE_CHAR) chars++;
+        }
+        break;
+      } finally {
+        Marshal.FreeHGlobal(buf);
+      }
+    }
+
+    // One line, parsed by the test. stdout here is one of the intended handles,
+    // so this line arriving at all is itself part of the evidence.
+    Console.WriteLine("LOOPLY-HANDLES pipes=" + pipes + " disks=" + disks + " chars=" + chars
+      + " inheritablePipes=" + inheritablePipes + " listed=" + listed + " total=" + total);
+    return 0;
+  }
+}