opensocrates 1.4.0 → 1.5.1

package/installer/opensocrates.mjs

@@ -15,6 +15,7 @@ import {
   chmod,
   chown,
   cp,
+  copyFile,
   lstat,
   mkdir,
   mkdtemp,
@@ -34,15 +35,16 @@ import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { fileURLToPath } from "node:url";
 
-export const PRODUCT_VERSION = "1.4.0";
+export const PRODUCT_VERSION = "1.5.1";
 export const REPOSITORY = "ParkerHwang/OpenSocrates";
 export const MARKETPLACE_NAME = "opensocrates";
 export const PLUGIN_NAME = "opensocrates";
 export const PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 export const DEFAULT_HOST = "codex";
 export const SUPPORTED_HOSTS = Object.freeze(["codex"]);
+export const MACOS_PROFILE_HOSTS = Object.freeze(["claude", "antigravity", "claude-chat"]);
 export const ALL_HOST = "all";
-export const HOST_CHOICES = Object.freeze([ALL_HOST, ...SUPPORTED_HOSTS]);
+export const HOST_CHOICES = Object.freeze([ALL_HOST, ...SUPPORTED_HOSTS, ...MACOS_PROFILE_HOSTS]);
 export function assetNameFor(host = DEFAULT_HOST) {
   if (!SUPPORTED_HOSTS.includes(host)) {
     fail(`unsupported host ${JSON.stringify(host)}`);
@@ -1599,6 +1601,10 @@ export function parseCli(argv) {
     "verify",
     "auto-update",
     "help",
+    "diagnose",
+    "disable",
+    "enable",
+    "export",
   ]);
   const args = [...argv];
   let action = "install";
@@ -1635,6 +1641,8 @@ export function parseCli(argv) {
     force: false,
     purge: false,
     resetTrust: false,
+    workspace: null,
+    output: null,
   };
   const seenOptions = new Set();
   while (args.length > 0) {
@@ -1652,6 +1660,12 @@ export function parseCli(argv) {
       options.host = host;
       continue;
     }
+    if (flag === "--workspace" || flag === "--output") {
+      const value = args.shift();
+      if (!value || value.startsWith("-")) fail(`${flag} requires a path`);
+      options[flag === "--workspace" ? "workspace" : "output"] = resolve(value);
+      continue;
+    }
     if (flag === "--allow-major") {
       seenOptions.add("allow-major");
       options.allowMajor = true;
@@ -1738,7 +1752,7 @@ export function parseCli(argv) {
   ) {
     fail("host-qualified asset options are only valid with --host all");
   }
-  if (["status", "remove", "help"].includes(options.action) && options.asset !== null) {
+  if (["status", "remove", "help", "diagnose", "disable", "enable"].includes(options.action) && options.asset !== null) {
     fail(`${options.action} does not accept --asset or --checksum`);
   }
   if (
@@ -1785,9 +1799,67 @@ export function parseCli(argv) {
   if (autoUpdateRun && seenOptions.has("host") && options.host !== ALL_HOST) {
     fail("auto-update run always reconciles desired state and only accepts --host all");
   }
+  if (options.workspace !== null && options.host !== "antigravity") {
+    fail("--workspace is only valid for Antigravity");
+  }
+  if (options.output !== null && !(options.host === "claude-chat" && options.action === "export")) {
+    fail("--output is only valid for the Claude account export");
+  }
+  if (options.host === "claude-chat" && !["export", "verify", "help"].includes(options.action)) {
+    fail("Claude account delivery uses export/verify; account activation is a separate UI action");
+  }
+  if (MACOS_PROFILE_HOSTS.includes(options.host) && (options.purge || options.resetTrust || options.action === "auto-update")) {
+    fail("additional profiles do not broaden purge, trust reset or automatic updates");
+  }
+  if (!MACOS_PROFILE_HOSTS.includes(options.host) && ["diagnose", "disable", "enable", "export"].includes(options.action)) {
+    fail(`${options.action} requires an additional profile`);
+  }
   return options;
 }
 
+function profileAssetName(host) {
+  if (!MACOS_PROFILE_HOSTS.includes(host)) fail("unknown content/native profile");
+  const suffix = host === "claude-chat" ? "skills" : "plugin";
+  return `opensocrates-${PRODUCT_VERSION}-${host}-${suffix}.zip`;
+}
+
+async function prepareProfilePackage(host, options) {
+  const scratch = await mkdtemp(join(tmpdir(), "opensocrates-profile-"));
+  try {
+    if (process.platform === "win32") windowsAction("seal-new", scratch);
+    const name = profileAssetName(host);
+    let asset = options.asset;
+    let checksum = options.checksum;
+    if (asset === null) {
+      asset = join(scratch, name);
+      checksum = join(scratch, name + ".sha256");
+      const base = `https://github.com/${REPOSITORY}/releases/download/v${PRODUCT_VERSION}`;
+      await downloadFile(base + "/" + name, asset);
+      await downloadFile(base + "/" + name + ".sha256", checksum);
+    }
+    const expected = parseChecksumText(await readFile(checksum, "utf8"), basename(asset));
+    if (await sha256File(asset) !== expected) fail("profile archive checksum mismatch");
+    await requireRegularFileEntry(asset, "profile archive");
+    const captured = join(scratch, "verified.zip");
+    await copyFile(asset, captured, fsConstants.COPYFILE_EXCL);
+    if (await sha256File(captured) !== expected) fail("profile archive changed during preparation");
+    asset = captured;
+    archiveEntries(asset);
+    if (process.platform !== "win32") {
+      const zipinfo = run("/usr/bin/zipinfo", ["-l", asset]);
+      if (/^[lbcps][-rwx]/mu.test(zipinfo.stdout)) fail("profile archive contains non-regular entries");
+    }
+    const root = join(scratch, "package");
+    await extractArchive(asset, root);
+    await walkFiles(root);
+    if (process.platform === "win32") windowsAction("seal-new", root);
+    return { root, asset, cleanup: async () => rm(scratch, { recursive: true, force: true }) };
+  } catch (error) {
+    await rm(scratch, { recursive: true, force: true });
+    throw error;
+  }
+}
+
 function showHelp() {
   console.log(`OpenSocrates ${PRODUCT_VERSION}
 
@@ -1797,6 +1869,15 @@ Usage:
   opensocrates update [--host codex|all] [--asset ZIP --checksum FILE]
   opensocrates remove [--host codex|all] [--purge [--reset-trust]]
   opensocrates verify [--host codex|all] [--asset ZIP --checksum FILE]
+  opensocrates install|update --host claude [--asset ZIP --checksum FILE]
+  opensocrates install|update --host antigravity [--workspace FOLDER]
+      [--asset ZIP --checksum FILE]
+  opensocrates status|diagnose|disable|enable|remove --host claude|antigravity
+      [--workspace FOLDER]
+  opensocrates verify --host claude|antigravity|claude-chat
+      [--asset ZIP --checksum FILE]
+  opensocrates export --host claude-chat --output ZIP
+      [--asset ZIP --checksum FILE]
   opensocrates auto-update enable [--host codex|all]
       [--channel stable|next] [--interval-hours ${AUTO_UPDATE_DEFAULT_INTERVAL_HOURS}]
       [--allow-major]
@@ -1807,7 +1888,13 @@ Without --asset, install, update, and verify download the v${PRODUCT_VERSION}
 package and checksum from GitHub Releases. The default lifecycle host is codex.
 With --host all, supplied host-qualified asset/checksum pairs define the exact
 transaction set and are never mixed with downloads for other hosts. Without
-qualified assets, every ready host participates. Automatic updates are opt-in.
+qualified assets, ready Codex hosts participate. The additional profiles
+require an explicit --host; all does not activate them. Automatic updates are opt-in
+for Codex. Claude native lifecycle requires macOS arm64 and the Claude CLI.
+Antigravity installs owned rules and skills globally or in the explicit workspace
+on macOS arm64 and Windows x64. Claude Chat exports a verified portable skill ZIP;
+upload and account activation happen
+through Claude's interface. These profiles do not accept purge or reset-trust.
 
 Ordinary remove unregisters the selected host and removes installer-managed
 files, but may leave host-owned caches, installer state, and Codex hook trust.
@@ -4344,9 +4431,22 @@ async function verifyPackages(options) {
 
 export async function main(argv = process.argv.slice(2), internalDependencies = {}) {
   const options = parseCli(argv);
+  if (MACOS_PROFILE_HOSTS.includes(options.host) && options.action !== "help") {
+    const { runManagedHost } = await import("./managed-hosts.mjs");
+    const operation = () => runManagedHost(options, {
+      version: PRODUCT_VERSION,
+      platform: process.platform,
+      claudeBinary: process.env.CLAUDE_BIN || "claude",
+      preparePackage: prepareProfilePackage,
+    });
+    const result = ["status", "diagnose", "verify", "export"].includes(options.action)
+      ? await operation() : await withOperationLock(operation);
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
   if (process.platform === "win32" && options.action === "auto-update") {
     const message =
-      "Automatic updates: unavailable on Windows in 1.4.0. Use opensocrates update --host all manually.";
+      `Automatic updates: unavailable on Windows in ${PRODUCT_VERSION}. Use opensocrates update --host all manually.`;
     if (options.autoUpdateAction === "status" || options.autoUpdateAction === "disable") {
       console.log(message);
       return 0;

package/installer/windows.ps1

@@ -1,8 +1,113 @@
 # Paths are data in environment variables, never interpolated PowerShell code.
-param([ValidateSet('entries','extract','private')][string]$Action)
+param([ValidateSet('entries','extract','private','check','check-tree','mkdir-private','seal-new','lease')][string]$Action)
 $ErrorActionPreference = 'Stop'
 [Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
-$targetPath = $env:OPENSOCRATES_WINDOWS_PATH
+function Native-Path([string]$path) {
+    $absolute = [IO.Path]::GetFullPath($path)
+    # PowerShell 5.1's FileSystemInfo ACL methods otherwise fail beyond MAX_PATH,
+    # including an owned tree temporarily moved below a transaction backup.
+    # Convert an already absolute local drive path; caller path/alias policy and
+    # every ownership, DACL and reparse check remain in force.
+    if ($absolute -match '^[a-zA-Z]:\\') { return '\\?\' + $absolute }
+    return $absolute
+}
+$targetPath = Native-Path $env:OPENSOCRATES_WINDOWS_PATH
+$currentIdentity = [Security.Principal.WindowsIdentity]::GetCurrent()
+$currentSid = $currentIdentity.User
+$trustedSids = @($currentSid.Value,'S-1-5-18','S-1-5-32-544')
+function Assert-Parents([string]$path) {
+    $cursor = [IO.Path]::GetFullPath($path)
+    while ($cursor) {
+        $item = Get-Item -LiteralPath $cursor -Force
+        if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'Reparse ancestor refused' }
+        $cursor = [IO.Path]::GetDirectoryName($cursor)
+    }
+}
+function Private-Acl([bool]$directory) {
+    $acl = if ($directory) { [Security.AccessControl.DirectorySecurity]::new() } else { [Security.AccessControl.FileSecurity]::new() }
+    $acl.SetOwner($currentSid)
+    $acl.SetAccessRuleProtection($true,$false)
+    $inherit = if ($directory) { 'ContainerInherit,ObjectInherit' } else { 'None' }
+    foreach ($identity in $trustedSids) {
+        $acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new([Security.Principal.SecurityIdentifier]::new($identity),'FullControl',$inherit,'None','Allow'))
+    }
+    return $acl
+}
+function Assert-Owned($item) {
+    if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'Reparse point refused' }
+    $acl = $item.GetAccessControl()
+    if ($acl.GetOwner([Security.Principal.SecurityIdentifier]).Value -ne $currentSid.Value) { throw 'Foreign owner refused' }
+    $writes = [Security.AccessControl.FileSystemRights]::Write -bor [Security.AccessControl.FileSystemRights]::Delete -bor [Security.AccessControl.FileSystemRights]::DeleteSubdirectoriesAndFiles -bor [Security.AccessControl.FileSystemRights]::ChangePermissions -bor [Security.AccessControl.FileSystemRights]::TakeOwnership
+    foreach ($rule in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])) {
+        if ($rule.PropagationFlags -band [Security.AccessControl.PropagationFlags]::InheritOnly) { continue }
+        if ($rule.AccessControlType -eq 'Allow' -and ($rule.FileSystemRights -band $writes) -and $rule.IdentityReference.Value -notin $trustedSids) { throw 'Untrusted writable DACL refused' }
+    }
+}
+function Tree-Items($rootItem) {
+    $pending = [Collections.Generic.Queue[IO.FileSystemInfo]]::new()
+    $pending.Enqueue($rootItem)
+    $count = 0
+    while ($pending.Count) {
+        $item = $pending.Dequeue()
+        if (++$count -gt 20000) { throw 'Filesystem limit exceeded' }
+        if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'Reparse point refused' }
+        $item
+        if ($item -is [IO.DirectoryInfo]) {
+            foreach ($child in $item.EnumerateFileSystemInfos()) { $pending.Enqueue($child) }
+        }
+    }
+}
+if ($Action -eq 'mkdir-private') {
+    if (Test-Path -LiteralPath $targetPath) { throw 'New private directory collision' }
+    Assert-Parents ([IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($targetPath)))
+    ([IO.DirectoryInfo]::new($targetPath)).Create((Private-Acl $true))
+    Assert-Owned (Get-Item -LiteralPath $targetPath -Force)
+    exit 0
+}
+if ($Action -in @('check','check-tree','seal-new','lease')) {
+    Assert-Parents $targetPath
+    $rootItem = Get-Item -LiteralPath $targetPath -Force
+    if ($Action -eq 'seal-new') {
+        # Caller uses this only for an exclusively created staging tree/file.
+        $items = @(Tree-Items $rootItem)
+        foreach ($item in $items) {
+            $owner = $item.GetAccessControl().GetOwner([Security.Principal.SecurityIdentifier]).Value
+            if ($owner -notin @($currentSid.Value,$currentIdentity.Owner.Value)) { throw 'Foreign staging owner refused' }
+        }
+        foreach ($item in $items) { $item.SetAccessControl((Private-Acl ($item -is [IO.DirectoryInfo]))) }
+    } elseif ($Action -eq 'check-tree') {
+        foreach ($item in (Tree-Items $rootItem)) { Assert-Owned $item }
+    } else { Assert-Owned $rootItem }
+    if ($Action -ne 'lease') { exit 0 }
+    # Pin ancestors without FILE_SHARE_DELETE while Node holds its operation lock.
+    Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+public static class OpenSocratesDirectoryLease {
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+  public static extern SafeFileHandle CreateFile(string name, uint access, uint share, IntPtr security, uint mode, uint flags, IntPtr template);
+}
+'@
+    $handles = [Collections.Generic.List[Microsoft.Win32.SafeHandles.SafeFileHandle]]::new()
+    try {
+        $cursor = [IO.Path]::GetFullPath($targetPath)
+        while ($cursor) {
+            # FILE_LIST_DIRECTORY establishes read sharing; access=0 does not
+            # participate in deletion sharing and cannot protect against rename.
+            $handle = [OpenSocratesDirectoryLease]::CreateFile($cursor,1,3,[IntPtr]::Zero,3,0x02200000,[IntPtr]::Zero)
+            if ($handle.IsInvalid) { throw 'Cannot pin managed ancestor' }
+            $handles.Add($handle)
+            $cursor = [IO.Path]::GetDirectoryName($cursor)
+        }
+        Assert-Parents $targetPath
+        Assert-Owned (Get-Item -LiteralPath $targetPath -Force)
+        [Console]::WriteLine('ready')
+        [Console]::Out.Flush()
+        [void][Console]::In.ReadLine()
+    } finally { foreach ($handle in $handles) { $handle.Dispose() } }
+    exit 0
+}
 if ($Action -eq 'private') {
     $item = Get-Item -LiteralPath $targetPath -Force
     if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'Reparse point refused' }
@@ -20,23 +125,37 @@ if ($Action -eq 'private') {
     exit 0
 }
 Add-Type -AssemblyName System.IO.Compression.FileSystem
+Assert-Parents $targetPath
 $zip = [IO.Compression.ZipFile]::OpenRead($targetPath)
 try {
     $names = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
+    $directories = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
     $total = 0L
     foreach ($entry in $zip.Entries) {
         $name = $entry.FullName
+        if ($name.EndsWith('/')) { [void]$directories.Add($name.TrimEnd('/')) }
         $parts = $name.TrimEnd('/').Split('/')
         if (!$name -or $name.Contains('\') -or $name.StartsWith('/') -or $name -match '[\x00-\x1f<>:"|?*]' -or
             ($parts | Where-Object { !$_ -or $_ -eq '.' -or $_ -eq '..' -or $_ -match '[. ]$' -or $_ -match '^(?i:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)' }) -or !$names.Add($name.TrimEnd('/'))) { throw 'Unsafe or duplicate ZIP path' }
-        if ((($entry.ExternalAttributes -shr 16) -band 0xF000) -eq 0xA000) { throw 'ZIP symlink refused' }
+        $kind = ($entry.ExternalAttributes -shr 16) -band 0xF000
+        if ($kind -notin @(0,0x4000,0x8000) -or ($entry.ExternalAttributes -band 0x400)) { throw 'ZIP non-regular entry refused' }
+        if ($kind -eq 0x4000 -and !$name.EndsWith('/')) { throw 'ZIP directory type mismatch' }
         $total += $entry.Length
         if ($total -gt 2147483648 -or $zip.Entries.Count -gt 20000) { throw 'ZIP limit exceeded' }
     }
+    foreach ($entry in $zip.Entries) {
+        $parentName = $entry.FullName.TrimEnd('/')
+        while ($parentName.Contains('/')) {
+            $parentName = $parentName.Substring(0,$parentName.LastIndexOf('/'))
+            if ($names.Contains($parentName) -and !$directories.Contains($parentName)) { throw 'ZIP file-directory collision' }
+        }
+    }
     if ($Action -eq 'entries') { ConvertTo-Json -InputObject @($zip.Entries | ForEach-Object { $_.FullName }) -Compress; exit 0 }
-    $destination = [IO.Path]::GetFullPath($env:OPENSOCRATES_WINDOWS_DESTINATION).TrimEnd('\') + '\'
+    $destination = (Native-Path $env:OPENSOCRATES_WINDOWS_DESTINATION).TrimEnd('\') + '\'
+    Assert-Parents $destination
     foreach ($entry in $zip.Entries) {
-        $output = [IO.Path]::GetFullPath([IO.Path]::Combine($destination,$entry.FullName))
+        # Extended Win32 paths do not translate the ZIP's portable slash syntax.
+        $output = [IO.Path]::GetFullPath([IO.Path]::Combine($destination,$entry.FullName.Replace('/','\')))
         if (!$output.StartsWith($destination,[StringComparison]::OrdinalIgnoreCase)) { throw 'ZIP path escape' }
         if ($entry.FullName.EndsWith('/')) { [void][IO.Directory]::CreateDirectory($output); continue }
         [void][IO.Directory]::CreateDirectory([IO.Path]::GetDirectoryName($output))

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "opensocrates",
-  "version": "1.4.0",
-  "description": "Install and manage OpenSocrates for Codex on macOS and Windows.",
+  "version": "1.5.1",
+  "description": "Original reasoning assistance with Codex, Claude account skills and Antigravity delivery.",
   "type": "module",
   "bin": {
     "opensocrates": "installer/opensocrates.mjs"
   },
   "files": [
     "installer/opensocrates.mjs",
+    "installer/managed-hosts.mjs",
     "installer/windows.ps1",
     "CHANGELOG.md",
     "SECURITY.md",
     "VERSION"
   ],
   "scripts": {
-    "test": "node --test installer/opensocrates.test.mjs installer/lifecycle.test.mjs tools/clean_machine_acceptance.test.mjs tools/reinstall_cycle_acceptance.test.mjs tools/release_gate.test.mjs && npm run test:npx",
+    "test": "node --test installer/opensocrates.test.mjs installer/lifecycle.test.mjs installer/managed-hosts.test.mjs tools/clean_machine_acceptance.test.mjs tools/reinstall_cycle_acceptance.test.mjs tools/release_gate.test.mjs && npm run test:npx",
     "test:npx": "node installer/package-smoke.mjs",
     "pack:check": "npm pack --dry-run",
     "prepublishOnly": "npm test",
-    "test:windows": "node --test installer/windows.test.mjs"
+    "test:windows": "node --test installer/windows.test.mjs installer/managed-windows.test.mjs"
   },
   "engines": {
     "node": ">=20"